fix runtime settings and empty chat responses

Author: idoubi

internal/agent/loop.go

@@ -2045,6 +2045,12 @@ func (a *Agent) HandleMessage(ctx context.Context, msg bus.InboundMessage) strin
 		a.maybeRecoverToolCalls(resp)
 
 		if !resp.HasToolCalls() {
+			if strings.TrimSpace(resp.Content) == "" {
+				emptyMsg := "model returned an empty response"
+				emitEvent(ctx, ChatEvent{Type: "error", Data: map[string]any{"message": emptyMsg}})
+				emitEvent(ctx, ChatEvent{Type: "done"})
+				return emptyMsg
+			}
 			asst := provider.Message{Role: "assistant", Content: resp.Content, Thinking: resp.Thinking, Timestamp: time.Now().UnixMilli(), RawAssistant: resp.RawAssistant}
 			sess.Append(asst)
 			emitEvent(ctx, ChatEvent{Type: "content", Data: map[string]any{"content": resp.Content}})

internal/config/config.go

@@ -168,6 +168,12 @@ type TaskQueueCfg struct {
 	TaskTimeoutSec int `json:"taskTimeoutSec,omitempty"`
 }
 
+// PrefsCfg holds runtime preferences that can be set at system, user, or
+// agent scope. Timezone is an IANA name such as "Asia/Shanghai".
+type PrefsCfg struct {
+	Timezone string `json:"timezone,omitempty"`
+}
+
 // SandboxCfg holds sandbox configuration for an agent.
 //
 // Image is the legacy single-slot image/template/snapshot — read-only
@@ -295,6 +301,7 @@ type Config struct {
 	Memory        MemoryCfg                  `json:"memory,omitempty"`
 	Privacy       PrivacyCfg                 `json:"privacy,omitempty"`
 	SkillsLearner SkillsLearnerCfg           `json:"skillsLearner,omitempty"`
+	Prefs         PrefsCfg                   `json:"prefs,omitempty"`
 }
 
 // ModelCost holds pricing info for a model.
@@ -359,9 +366,9 @@ type AgentDefaults struct {
 	// naturally serializes. 0 = unlimited (no cap, current behavior).
 	// Useful when downstream APIs (Brave free tier 1RPS, etc.) can't
 	// take a parallel burst.
-	MaxParallelToolCalls int     `json:"maxParallelToolCalls,omitempty"`
-	Thinking             string  `json:"thinking,omitempty"`
-	PolicyPreset         string  `json:"policy,omitempty"`
+	MaxParallelToolCalls int    `json:"maxParallelToolCalls,omitempty"`
+	Thinking             string `json:"thinking,omitempty"`
+	PolicyPreset         string `json:"policy,omitempty"`
 	// PromptMode lives here so the agent-scope `agents.defaults`
 	// config row (written by CLI and dashboard) round-trips into
 	// ResolvedAgent at userspace assembly time — see
@@ -389,8 +396,8 @@ type AgentDefaults struct {
 // configs table at scope=agent and are merged in via scope.SettingInto
 // during userspace load.
 type AgentEntry struct {
-	ID                   string                     `json:"id"`
-	UserID               string                     `json:"userId,omitempty"`
+	ID     string `json:"id"`
+	UserID string `json:"userId,omitempty"`
 	// Name mirrors agents.name (the operator-given display name) and is
 	// carried through to ResolvedAgent.DisplayName so the system prompt
 	// can stamp a fallback identity line when IDENTITY.md is empty.
@@ -400,12 +407,12 @@ type AgentEntry struct {
 	Temperature          float64                    `json:"temperature,omitempty"`
 	MaxToolIterations    int                        `json:"maxToolIterations,omitempty"`
 	MaxParallelToolCalls int                        `json:"maxParallelToolCalls,omitempty"`
-	Skills            []string                   `json:"skills,omitempty"`
-	MCPServers        map[string]MCPServerConfig `json:"mcpServers,omitempty"`
-	AlwaysLoadSkills  []string                   `json:"alwaysLoadSkills,omitempty"`
-	Thinking          string                     `json:"thinking,omitempty"`
-	Sandbox           SandboxCfg                 `json:"sandbox,omitempty"`
-	PolicyPreset      string                     `json:"policy,omitempty"`
+	Skills               []string                   `json:"skills,omitempty"`
+	MCPServers           map[string]MCPServerConfig `json:"mcpServers,omitempty"`
+	AlwaysLoadSkills     []string                   `json:"alwaysLoadSkills,omitempty"`
+	Thinking             string                     `json:"thinking,omitempty"`
+	Sandbox              SandboxCfg                 `json:"sandbox,omitempty"`
+	PolicyPreset         string                     `json:"policy,omitempty"`
 	// PromptMode selects how heavily the framework system prompt
 	// participates AND which built-in tools the LLM sees. Empty =
 	// "agent" (current default) for backward compatibility. See
@@ -537,12 +544,12 @@ type AgentFileConfig struct {
 	Temperature          float64                    `json:"temperature,omitempty"`
 	MaxToolIterations    int                        `json:"maxToolIterations,omitempty"`
 	MaxParallelToolCalls int                        `json:"maxParallelToolCalls,omitempty"`
-	Workspace         string                     `json:"workspace,omitempty"`
-	Skills            SkillsConfig               `json:"skills,omitempty"`
-	MCPServers        map[string]MCPServerConfig `json:"mcpServers,omitempty"`
-	ToolProviders     map[string]ToolProviderCfg `json:"toolProviders,omitempty"`
-	Tools             map[string]ToolCategoryCfg `json:"tools,omitempty"`
-	Providers         map[string]ProviderConfig  `json:"providers,omitempty"`
+	Workspace            string                     `json:"workspace,omitempty"`
+	Skills               SkillsConfig               `json:"skills,omitempty"`
+	MCPServers           map[string]MCPServerConfig `json:"mcpServers,omitempty"`
+	ToolProviders        map[string]ToolProviderCfg `json:"toolProviders,omitempty"`
+	Tools                map[string]ToolCategoryCfg `json:"tools,omitempty"`
+	Providers            map[string]ProviderConfig  `json:"providers,omitempty"`
 	// PromptMode mirrors AgentEntry.PromptMode at the file-config layer.
 	// Non-empty values override the entry-level setting.
 	PromptMode string `json:"promptMode,omitempty"`
@@ -608,13 +615,13 @@ type ResolvedAgent struct {
 	MaxToolIterations    int
 	MaxParallelToolCalls int
 	Thinking             string
-	Skills            SkillsConfig
-	MCPServers        map[string]MCPServerConfig
-	Sandbox           SandboxCfg
-	PolicyPreset      string
-	ToolProviders     map[string]ToolProviderCfg
-	Tools             map[string]ToolCategoryCfg
-	Providers         map[string]ProviderConfig
+	Skills               SkillsConfig
+	MCPServers           map[string]MCPServerConfig
+	Sandbox              SandboxCfg
+	PolicyPreset         string
+	ToolProviders        map[string]ToolProviderCfg
+	Tools                map[string]ToolCategoryCfg
+	Providers            map[string]ProviderConfig
 	// Admins is the per-channel admin allowlist for write-mode slash
 	// commands. See AgentFileConfig.Admins for semantics + default.
 	Admins map[string][]string

internal/provider/anthropic.go

@@ -240,6 +240,15 @@ func toAnthropicMessages(msgs []Message) (string, []anthropicMessage) {
 			am.Content, _ = json.Marshal("")
 		}
 
+		if len(am.Content) == 0 {
+			// Some Anthropic-compatible providers (notably z.ai) reject
+			// `content: null` even though a degenerate empty assistant
+			// message can appear in historical sessions after an aborted
+			// or empty streamed turn. The schema accepts a string, so
+			// serialize the empty content explicitly instead of letting
+			// json.RawMessage's nil value become null.
+			am.Content, _ = json.Marshal("")
+		}
 		out = append(out, am)
 	}
 

internal/provider/anthropic_orphan_test.go

@@ -153,6 +153,31 @@ func TestToAnthropicMessagesOrphanAssistantRawOnly(t *testing.T) {
 	}
 }
 
+func TestToAnthropicMessagesEmptyAssistantDoesNotEmitNullContent(t *testing.T) {
+	msgs := []Message{
+		{Role: "user", Content: "hello"},
+		{Role: "assistant"},
+		{Role: "user", Content: "are you there?"},
+	}
+
+	_, out := toAnthropicMessages(msgs)
+
+	if len(out) != 3 {
+		t.Fatalf("expected 3 messages, got %d: %+v", len(out), out)
+	}
+	if out[1].Role != "assistant" {
+		t.Fatalf("message[1] role = %q, want assistant", out[1].Role)
+	}
+	if string(out[1].Content) != `""` {
+		t.Fatalf("message[1] content = %s, want JSON empty string", string(out[1].Content))
+	}
+	for i, am := range out {
+		if string(am.Content) == "null" || len(am.Content) == 0 {
+			t.Fatalf("message[%d] has null/empty content: %+v", i, am)
+		}
+	}
+}
+
 func allText(out []anthropicMessage) string {
 	var sb strings.Builder
 	for _, am := range out {

internal/setup/handlers.go

@@ -52,6 +52,9 @@ func (s *Server) loadUserConfig(r *http.Request) (*config.Config, error) {
 			return nil, err
 		}
 	}
+	if err := scope.SettingInto(r.Context(), s.dataStore, scope.PrefsNamespace, uid, "", &cfg.Prefs); err != nil {
+		return nil, err
+	}
 	if provs, err := scope.Providers(r.Context(), s.dataStore, uid, ""); err == nil {
 		for k, v := range provs {
 			cfg.Providers[k] = v
@@ -197,7 +200,7 @@ var settingNamespaces = []settingNamespace{
 		dst:     func(c *config.Config) interface{} { return &c.Teams },
 		collect: func(c *config.Config) map[string]interface{} { return wrapKeyed(c.Teams) }},
 	{namespace: "bindings",
-		dst:     func(c *config.Config) interface{} { return &c.Bindings },
+		dst: func(c *config.Config) interface{} { return &c.Bindings },
 		collect: func(c *config.Config) map[string]interface{} {
 			if len(c.Bindings) == 0 {
 				return nil
@@ -506,6 +509,7 @@ func (s *Server) handleGetConfig(w http.ResponseWriter, r *http.Request) {
 	if s.dataStore != nil {
 		_ = scope.SettingInto(r.Context(), s.dataStore, "agents.defaults", "", "", &sysDefaults)
 	}
+	serverTimezone := time.Local.String()
 	// Marshal-then-extend keeps the response shape compatible (existing
 	// callers ignore the extra `meta` key) without forcing a refactor of
 	// config.Config to carry presentation metadata.
@@ -514,6 +518,7 @@ func (s *Server) handleGetConfig(w http.ResponseWriter, r *http.Request) {
 	_ = json.Unmarshal(blob, &out)
 	out["meta"] = map[string]any{
 		"systemDefaultModel": sysDefaults.Model,
+		"serverTimezone":     serverTimezone,
 	}
 	jsonResponse(w, http.StatusOK, out)
 }
@@ -534,6 +539,22 @@ func (s *Server) handleUpdateConfig(w http.ResponseWriter, r *http.Request) {
 		jsonResponse(w, http.StatusBadRequest, map[string]any{"ok": false, "error": err.Error()})
 		return
 	}
+	var raw struct {
+		Prefs  *config.PrefsCfg `json:"prefs"`
+		Skills *struct {
+			AgentEntries map[string]map[string]config.SkillEntryCfg `json:"agentEntries"`
+		} `json:"skills"`
+	}
+	_ = json.Unmarshal(buf, &raw)
+	if raw.Prefs != nil {
+		raw.Prefs.Timezone = strings.TrimSpace(raw.Prefs.Timezone)
+		if raw.Prefs.Timezone != "" {
+			if _, err := time.LoadLocation(raw.Prefs.Timezone); err != nil {
+				jsonResponse(w, http.StatusBadRequest, map[string]any{"ok": false, "error": "invalid timezone: use an IANA name like Asia/Shanghai"})
+				return
+			}
+		}
+	}
 	merged, err := s.loadUserConfig(r)
 	if err != nil {
 		jsonResponse(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": err.Error()})
@@ -556,12 +577,18 @@ func (s *Server) handleUpdateConfig(w http.ResponseWriter, r *http.Request) {
 	// name=skills.entries). Pull from the raw body — not from the
 	// merged Config — so we only touch agents the caller actually
 	// patched, and don't echo every existing override back as a write.
-	var raw struct {
-		Skills *struct {
-			AgentEntries map[string]map[string]config.SkillEntryCfg `json:"agentEntries"`
-		} `json:"skills"`
+	if raw.Prefs != nil {
+		sc, scopeID := s.scopeForSave(r)
+		uid, aid := scope.OwnershipFromScope(sc, scopeID)
+		data := map[string]interface{}{}
+		if raw.Prefs.Timezone != "" {
+			data["timezone"] = raw.Prefs.Timezone
+		}
+		if err := scope.SaveSetting(r.Context(), s.dataStore, uid, aid, scope.PrefsNamespace, data); err != nil {
+			jsonResponse(w, http.StatusInternalServerError, map[string]any{"ok": false, "error": err.Error()})
+			return
+		}
 	}
-	_ = json.Unmarshal(buf, &raw)
 	if raw.Skills != nil && raw.Skills.AgentEntries != nil {
 		for agentID, entries := range raw.Skills.AgentEntries {
 			rec, err := s.dataStore.GetAgent(r.Context(), agentID)
@@ -810,15 +837,15 @@ func (s *Server) handleListTasks(w http.ResponseWriter, r *http.Request) {
 // --- chat handlers (delegate to per-user agent) ---
 
 type chatRequest struct {
-	AgentID   string         `json:"agentId,omitempty"`
-	SessionID string         `json:"sessionId"`
+	AgentID   string `json:"agentId,omitempty"`
+	SessionID string `json:"sessionId"`
 	// ProjectID, when non-empty AND the session row doesn't yet exist,
 	// is the "this chat belongs to project X" hint the URL carries
 	// (`?project=<pid>`) before the first message. Once the row exists
 	// it's authoritative — the server reads project_id from the row
 	// and ignores any later hint.
-	ProjectID string         `json:"projectId,omitempty"`
-	Message   string         `json:"message"`
+	ProjectID string `json:"projectId,omitempty"`
+	Message   string `json:"message"`
 	// Images carries data URLs / HTTPS URLs for image attachments. The
 	// web client historically sends them under `imageUrls` (camelCase)
 	// while the API path uses `images`; we accept both and merge below
@@ -1073,6 +1100,7 @@ func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) {
 	defer keepalive.Stop()
 
 	clientGone := r.Context().Done()
+	forwardedAny := false
 	// turnPending flips on when the slash handler reports it queued a
 	// continuation via bus.Inbound (`turn_pending` event). The POST
 	// goroutine's HandleMessage has already returned, but the real
@@ -1109,9 +1137,12 @@ func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) {
 						continue
 					}
 					if env.Event.Type == "done" {
+						forwardEvent(w, flusher, env)
+						forwardedAny = true
 						return
 					}
 					forwardEvent(w, flusher, env)
+					forwardedAny = true
 				default:
 					break drain
 				}
@@ -1124,6 +1155,12 @@ func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) {
 				agentDone = nil
 				continue
 			}
+			if !forwardedAny {
+				forwardSyntheticEvent(w, flusher, agent.ChatEvent{
+					Type: "error",
+					Data: map[string]any{"message": "agent finished without emitting a response"},
+				})
+			}
 			return
 		case <-agentCtx.Done():
 			// Safety net for the turnPending path above: bail out at
@@ -1142,6 +1179,7 @@ func (s *Server) handleChatStream(w http.ResponseWriter, r *http.Request) {
 				continue
 			}
 			forwardEvent(w, flusher, env)
+			forwardedAny = true
 			if env.Event.Type == "done" {
 				return
 			}
@@ -1170,24 +1208,28 @@ func forwardEvent(w http.ResponseWriter, flusher http.Flusher, env agent.EventEn
 	flusher.Flush()
 }
 
+func forwardSyntheticEvent(w http.ResponseWriter, flusher http.Flusher, evt agent.ChatEvent) {
+	forwardEvent(w, flusher, agent.EventEnvelope{Seq: -1, Event: evt})
+}
+
 // handleChatSubscribe holds an SSE connection open for one (agent,
 // session) pair and forwards three kinds of traffic:
 //
-//   1. Replay: session_events rows with seq > since (or > Last-Event-ID)
-//      that the client missed before connecting. Lets a freshly
-//      reloaded page pick up an in-flight turn without the rest of the
-//      reply disappearing.
+//  1. Replay: session_events rows with seq > since (or > Last-Event-ID)
+//     that the client missed before connecting. Lets a freshly
+//     reloaded page pick up an in-flight turn without the rest of the
+//     reply disappearing.
 //
-//   2. Live agent chat events from the hub — every emitEvent call from
-//      the agent loop fans through here. This covers both the
-//      synchronous POST /api/chat/stream path AND turns started by
-//      other tabs / cron firings, so any open chat panel sees them
-//      regardless of who triggered the work.
+//  2. Live agent chat events from the hub — every emitEvent call from
+//     the agent loop fans through here. This covers both the
+//     synchronous POST /api/chat/stream path AND turns started by
+//     other tabs / cron firings, so any open chat panel sees them
+//     regardless of who triggered the work.
 //
-//   3. Legacy WebChannel bus messages — cron-fired final replies that
-//      route through bus.Outbound rather than the chat-event path.
-//      Kept so we don't lose pre-existing functionality during the
-//      transition.
+//  3. Legacy WebChannel bus messages — cron-fired final replies that
+//     route through bus.Outbound rather than the chat-event path.
+//     Kept so we don't lose pre-existing functionality during the
+//     transition.
 //
 // Auth gating reuses resolveAgent, so the caller must already have
 // permission to chat with this agent. The subscription doesn't
@@ -1431,9 +1473,9 @@ func (s *Server) readWorkspaceFileBytes(ctx context.Context, agentID, relPath st
 // parseTodoMarkdown extracts checkbox lines from a todo.md body and
 // returns them as structured items. Conventions:
 //
-//	- [ ] text   → pending
-//	- [x] text   → completed
-//	- [X] text   → completed (case-insensitive)
+//   - [ ] text   → pending
+//   - [x] text   → completed
+//   - [X] text   → completed (case-insensitive)
 //
 // Anything else (heading lines, blank lines, non-checkbox bullets) is
 // ignored — todo.md doubles as a human-readable plan document, so we
@@ -1647,10 +1689,10 @@ func (s *Server) handleChats(w http.ResponseWriter, r *http.Request) {
 	}
 	totalPages := (total + pageSize - 1) / pageSize
 	jsonResponse(w, http.StatusOK, map[string]any{
-		"sessions":  out,
-		"page":      page,
-		"pageSize":  pageSize,
-		"total":     total,
+		"sessions":   out,
+		"page":       page,
+		"pageSize":   pageSize,
+		"total":      total,
 		"totalPages": totalPages,
 	})
 }