fix: prevent nil pointer crash in OpenAI SSE tool call accumulation

cmd/gateway.go

@@ -8,6 +8,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"syscall"
+	"time"
 
 	"github.com/google/uuid"
 
@@ -308,6 +309,18 @@ func runGateway() {
 		}()
 	}
 
+	// Sweep orphan traces left by previous crashes (running > 1h)
+	if pgStores.Tracing != nil {
+		go func() {
+			n, err := pgStores.Tracing.SweepOrphanTraces(context.Background(), time.Hour)
+			if err != nil {
+				slog.Warn("orphan trace sweep failed", "error", err)
+			} else if n > 0 {
+				slog.Info("orphan trace sweep complete", "swept", n)
+			}
+		}()
+	}
+
 	// Redis cache: compiled via build tags. Build with 'go build -tags redis' to enable.
 	redisClient := initRedisClient(cfg)
 	defer shutdownRedis(redisClient)
@@ -818,6 +831,11 @@ func runGateway() {
 	// Register channels/instances/links/teams RPC methods
 	wireChannelRPCMethods(server, pgStores, channelMgr, agentRouter, msgBus)
 
+	// Register party mode WS RPC methods
+	if pgStores.Party != nil {
+		methods.NewPartyMethods(pgStores.Party, pgStores.Agents, providerRegistry, msgBus).Register(server.Router())
+	}
+
 	// Wire channel event subscribers (cache invalidation, pairing, cascade disable)
 	wireChannelEventSubscribers(msgBus, server, pgStores, channelMgr, instanceLoader, pairingMethods, cfg)
 

cmd/gateway_providers.go

@@ -319,7 +319,8 @@ func registerProvidersFromDB(registry *providers.Registry, provStore store.Provi
 			prov.WithProviderType(p.ProviderType)
 			registry.Register(prov)
 		default:
-			prov := providers.NewOpenAIProvider(p.Name, p.APIKey, p.APIBase, "")
+			defaultModel := extractDefaultModel(p.Settings)
+			prov := providers.NewOpenAIProvider(p.Name, p.APIKey, p.APIBase, defaultModel)
 			prov.WithProviderType(p.ProviderType)
 			if p.ProviderType == store.ProviderMiniMax {
 				prov.WithChatPath("/text/chatcompletion_v2")
@@ -329,3 +330,17 @@ func registerProvidersFromDB(registry *providers.Registry, provStore store.Provi
 		slog.Info("registered provider from DB", "name", p.Name)
 	}
 }
+
+// extractDefaultModel reads default_model from a provider's settings JSONB.
+func extractDefaultModel(settings json.RawMessage) string {
+	if len(settings) == 0 {
+		return ""
+	}
+	var s struct {
+		DefaultModel string `json:"default_model"`
+	}
+	if json.Unmarshal(settings, &s) == nil {
+		return s.DefaultModel
+	}
+	return ""
+}

internal/agent/loop.go

@@ -325,7 +325,7 @@ func (l *Loop) runLoop(ctx context.Context, req RunRequest) (*RunResult, error)
 					reminder := "[System] " + strings.Join(parts, "\n\n")
 					messages = append(messages,
 						providers.Message{Role: "user", Content: reminder},
-						providers.Message{Role: "assistant", Content: "I see the task status. Let me handle accordingly."},
+						// No assistant prefill — thinking models reject it.
 					)
 				}
 			}
@@ -430,7 +430,7 @@ func (l *Loop) runLoop(ctx context.Context, req RunRequest) (*RunResult, error)
 			Tools:    toolDefs,
 			Model:    l.model,
 			Options: map[string]any{
-				providers.OptMaxTokens:   8192,
+				providers.OptMaxTokens:   l.maxTokens,
 				providers.OptTemperature: 0.7,
 				providers.OptSessionKey:  req.SessionKey,
 				providers.OptAgentID:     l.agentUUID.String(),
@@ -506,6 +506,28 @@ func (l *Loop) runLoop(ctx context.Context, req RunRequest) (*RunResult, error)
 			}
 		}
 
+		// Truncation guard: if response was cut off (max_tokens reached) and has tool calls,
+		// the tool call arguments are likely incomplete/malformed. Skip execution and ask
+		// the LLM to re-issue with complete arguments or break into smaller parts.
+		if resp.FinishReason == "length" && len(resp.ToolCalls) > 0 {
+			slog.Warn("truncated tool calls detected",
+				"agent", l.id, "iteration", iteration,
+				"tool_calls", len(resp.ToolCalls), "max_tokens", l.maxTokens)
+			messages = append(messages,
+				providers.Message{Role: "assistant", Content: resp.Content, ToolCalls: resp.ToolCalls,
+					Thinking: resp.Thinking, RawAssistantContent: resp.RawAssistantContent},
+				providers.Message{
+					Role:    "user",
+					Content: "[System] Your response was truncated (max_tokens reached). The last tool call had incomplete arguments. Do NOT re-issue the same large tool call. Instead, break your work into smaller steps or respond with text only.",
+				},
+			)
+			pendingMsgs = append(pendingMsgs,
+				providers.Message{Role: "assistant", Content: resp.Content, ToolCalls: resp.ToolCalls},
+				providers.Message{Role: "user", Content: "[System] Response truncated — tool call skipped."},
+			)
+			continue
+		}
+
 		if resp.Usage != nil {
 			totalUsage.PromptTokens += resp.Usage.PromptTokens
 			totalUsage.CompletionTokens += resp.Usage.CompletionTokens

internal/agent/loop_history.go

@@ -285,7 +285,7 @@ func limitHistoryTurns(msgs []providers.Message, limit int) []providers.Message
 //   - Orphaned tool messages at start of history (after truncation)
 //   - tool_result without matching tool_use in preceding assistant message
 //   - assistant with tool_calls but missing tool_results
-// sanitizeHistory repairs tool_use/tool_result pairing in session history.
+//
 // Returns the cleaned messages and the number of messages that were dropped or synthesized.
 func sanitizeHistory(msgs []providers.Message) ([]providers.Message, int) {
 	if len(msgs) == 0 {
@@ -301,6 +301,7 @@ func sanitizeHistory(msgs []providers.Message) ([]providers.Message, int) {
 			"tool_call_id", msgs[start].ToolCallID)
 		dropped++
 		start++
+		dropped++
 	}
 
 	if start >= len(msgs) {

internal/agent/loop_types.go

@@ -46,6 +46,7 @@ type Loop struct {
 	contextWindow int
 	maxIterations int
 	maxToolCalls  int
+	maxTokens     int
 	workspace        string
 	workspaceSharing *store.WorkspaceSharingConfig
 
@@ -154,6 +155,7 @@ type LoopConfig struct {
 	ContextWindow   int
 	MaxIterations   int
 	MaxToolCalls    int
+	MaxTokens       int
 	Workspace        string
 	WorkspaceSharing *store.WorkspaceSharingConfig
 
@@ -263,6 +265,7 @@ func NewLoop(cfg LoopConfig) *Loop {
 		contextWindow:          cfg.ContextWindow,
 		maxIterations:          cfg.MaxIterations,
 		maxToolCalls:           cfg.MaxToolCalls,
+		maxTokens:              cfg.MaxTokens,
 		workspace:              cfg.Workspace,
 		workspaceSharing:       cfg.WorkspaceSharing,
 		restrictToWs:           cfg.RestrictToWs,

internal/agent/resolver.go

@@ -231,6 +231,10 @@ func NewManagedResolver(deps ResolverDeps) ResolverFunc {
 		if maxIter <= 0 {
 			maxIter = 20
 		}
+		maxTokens := ag.ParseMaxTokens()
+		if maxTokens <= 0 {
+			maxTokens = 8192
+		}
 
 		// Per-agent config overrides (fallback to global defaults from config.json)
 		compactionCfg := deps.CompactionCfg
@@ -357,6 +361,7 @@ func NewManagedResolver(deps ResolverDeps) ResolverFunc {
 			Model:                  ag.Model,
 			ContextWindow:          contextWindow,
 			MaxIterations:          maxIter,
+			MaxTokens:              maxTokens,
 			Workspace:              workspace,
 			RestrictToWs:           &restrictVal,
 			SubagentsCfg:           ag.ParseSubagentsConfig(),

internal/channels/zalo/zalo.go

@@ -89,7 +89,7 @@ func (c *Channel) Start(ctx context.Context) error {
 	if err != nil {
 		return fmt.Errorf("zalo getMe failed: %w", err)
 	}
-	slog.Info("zalo bot connected", "bot_id", info.ID, "bot_name", info.Name)
+	slog.Info("zalo bot connected", "bot_id", info.ID, "bot_name", info.Label())
 
 	c.SetRunning(true)
 
@@ -418,29 +418,41 @@ type zaloAPIResponse struct {
 }
 
 type zaloBotInfo struct {
-	ID   string `json:"id"`
-	Name string `json:"name"`
+	ID          string `json:"id"`
+	Name        string `json:"account_name"`
+	DisplayName string `json:"display_name"`
+}
+
+func (b *zaloBotInfo) Label() string {
+	if b.DisplayName != "" {
+		return b.DisplayName
+	}
+	return b.Name
 }
 
 type zaloMessage struct {
-	MessageID string   `json:"message_id"`
-	Text      string   `json:"text"`
-	Photo     string   `json:"photo"`
-	PhotoURL  string   `json:"photo_url"`
-	Caption   string   `json:"caption"`
-	From      zaloFrom `json:"from"`
-	Chat      zaloChat `json:"chat"`
-	Date      int64    `json:"date"`
+	MessageID   string   `json:"message_id"`
+	MessageType string   `json:"message_type"`
+	Text        string   `json:"text"`
+	Photo       string   `json:"photo"`
+	PhotoURL    string   `json:"photo_url"`
+	Caption     string   `json:"caption"`
+	From        zaloFrom `json:"from"`
+	Chat        zaloChat `json:"chat"`
+	Date        int64    `json:"date"`
 }
 
 type zaloFrom struct {
-	ID       string `json:"id"`
-	Username string `json:"username"`
+	ID          string `json:"id"`
+	Username    string `json:"username"`
+	DisplayName string `json:"display_name"`
+	IsBot       bool   `json:"is_bot"`
 }
 
 type zaloChat struct {
-	ID   string `json:"id"`
-	Type string `json:"type"`
+	ID       string `json:"id"`
+	Type     string `json:"type"`
+	ChatType string `json:"chat_type"`
 }
 
 type zaloUpdate struct {
@@ -514,11 +526,28 @@ func (c *Channel) getUpdates(timeout int) ([]zaloUpdate, error) {
 		return nil, err
 	}
 
+	// Try array first
 	var updates []zaloUpdate
-	if err := json.Unmarshal(result, &updates); err != nil {
+	if err := json.Unmarshal(result, &updates); err == nil {
+		return updates, nil
+	}
+
+	// Try single object (Zalo Bot Platform returns one update at a time)
+	var single zaloUpdate
+	if err := json.Unmarshal(result, &single); err == nil && single.EventName != "" {
+		slog.Info("zalo update received", "event", single.EventName)
+		return []zaloUpdate{single}, nil
+	}
+
+	// Try wrapped {"updates": [...]}
+	var wrapped struct {
+		Updates []zaloUpdate `json:"updates"`
+	}
+	if err := json.Unmarshal(result, &wrapped); err != nil {
+		slog.Warn("zalo getUpdates unknown format", "raw", string(result[:min(len(result), 500)]))
 		return nil, fmt.Errorf("unmarshal updates: %w", err)
 	}
-	return updates, nil
+	return wrapped.Updates, nil
 }
 
 func (c *Channel) sendMessage(chatID, text string) error {