@geminilight/mindos 0.5.12 → 0.5.13

package/app/lib/agent/context.ts

@@ -0,0 +1,317 @@
+/**
+ * Phase 3: Context management — token estimation, compaction, tool output truncation.
+ *
+ * All operations are request-scoped (no persistence to frontend session).
+ */
+import { generateText, type ModelMessage, type ToolResultPart, type ToolModelMessage } from 'ai';
+import type { LanguageModel } from 'ai';
+
+// ---------------------------------------------------------------------------
+// Token estimation (1 token ≈ 4 chars)
+// ---------------------------------------------------------------------------
+
+/** Rough token count for a single ModelMessage */
+function messageTokens(msg: ModelMessage): number {
+  if (typeof msg.content === 'string') return Math.ceil(msg.content.length / 4);
+  if (Array.isArray(msg.content)) {
+    let chars = 0;
+    for (const part of msg.content) {
+      if ('text' in part && typeof part.text === 'string') chars += part.text.length;
+      if ('value' in part && typeof part.value === 'string') chars += part.value.length;
+      if ('input' in part) chars += JSON.stringify(part.input).length;
+    }
+    return Math.ceil(chars / 4);
+  }
+  return 0;
+}
+
+/** Estimate total tokens for a message array */
+export function estimateTokens(messages: ModelMessage[]): number {
+  let total = 0;
+  for (const m of messages) total += messageTokens(m);
+  return total;
+}
+
+/** Estimate tokens for a plain string (e.g. system prompt) */
+export function estimateStringTokens(text: string): number {
+  return Math.ceil(text.length / 4);
+}
+
+// ---------------------------------------------------------------------------
+// Context limits by model family
+// ---------------------------------------------------------------------------
+
+const MODEL_LIMITS: Record<string, number> = {
+  'claude': 200_000,
+  'gpt-4o': 128_000,
+  'gpt-4': 128_000,
+  'gpt-3.5': 16_000,
+  'gpt-5': 200_000,
+};
+
+// Sort by prefix length descending so "gpt-4o" matches before "gpt-4"
+const MODEL_LIMIT_ENTRIES = Object.entries(MODEL_LIMITS)
+  .sort((a, b) => b[0].length - a[0].length);
+
+/** Get context token limit for a model string */
+export function getContextLimit(model: string): number {
+  const lower = model.toLowerCase();
+  for (const [prefix, limit] of MODEL_LIMIT_ENTRIES) {
+    if (lower.includes(prefix)) return limit;
+  }
+  return 100_000; // conservative default
+}
+
+/** Check if messages + system prompt exceed threshold of context limit */
+export function needsCompact(
+  messages: ModelMessage[],
+  systemPrompt: string,
+  model: string,
+  threshold = 0.7,
+): boolean {
+  const total = estimateTokens(messages) + estimateStringTokens(systemPrompt);
+  const limit = getContextLimit(model);
+  return total > limit * threshold;
+}
+
+// ---------------------------------------------------------------------------
+// Tool output truncation (per-tool-type thresholds)
+// ---------------------------------------------------------------------------
+
+const TOOL_OUTPUT_LIMITS: Record<string, number> = {
+  // List/search tools — only need to know "what was found"
+  search: 500,
+  list_files: 500,
+  get_recent: 500,
+  get_backlinks: 500,
+  get_history: 500,
+  // Read tools — some context value, but not full file
+  read_file: 2000,
+  get_file_at_version: 2000,
+  // Write tools — only need success/failure
+  write_file: 200,
+  create_file: 200,
+  delete_file: 200,
+  rename_file: 200,
+  move_file: 200,
+  append_to_file: 200,
+  insert_after_heading: 200,
+  update_section: 200,
+  append_csv: 200,
+};
+
+/**
+ * Truncate tool outputs in historical messages to save tokens.
+ * Only truncates non-last tool messages (the last tool message is kept intact
+ * because the model may need its full output for the current step).
+ */
+export function truncateToolOutputs(messages: ModelMessage[]): ModelMessage[] {
+  // Find the index of the last 'tool' role message
+  let lastToolIdx = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'tool') { lastToolIdx = i; break; }
+  }
+
+  return messages.map((msg, idx) => {
+    if (msg.role !== 'tool' || idx === lastToolIdx) return msg;
+
+    const toolMsg = msg as ToolModelMessage;
+    const truncatedContent = toolMsg.content.map(part => {
+      if (part.type !== 'tool-result') return part;
+      const trp = part as ToolResultPart;
+      const toolName = trp.toolName ?? '';
+      const limit = TOOL_OUTPUT_LIMITS[toolName] ?? 500;
+      if (!trp.output || typeof trp.output !== 'object' || trp.output.type !== 'text') return part;
+      if (trp.output.value.length <= limit) return part;
+
+      return {
+        ...trp,
+        output: {
+          ...trp.output,
+          value: trp.output.value.slice(0, limit) + `\n[...truncated from ${trp.output.value.length} chars]`,
+        },
+      } satisfies ToolResultPart;
+    });
+
+    return { ...toolMsg, content: truncatedContent } satisfies ToolModelMessage;
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Compact: summarize early messages via LLM
+// ---------------------------------------------------------------------------
+
+const COMPACT_PROMPT = `Summarize the key points, decisions, and file operations from this conversation in under 500 words. Focus on:
+- What the user asked for
+- What files were read, created, or modified
+- Key decisions and outcomes
+- Any unresolved issues
+
+Be concise and factual. Output only the summary, no preamble.`;
+
+/** Extract a short text representation from a ModelMessage for summarization */
+function messageToText(m: ModelMessage): string {
+  const role = m.role;
+  let content = '';
+  if (typeof m.content === 'string') {
+    content = m.content;
+  } else if (Array.isArray(m.content)) {
+    const pieces: string[] = [];
+    for (const part of m.content) {
+      if ('text' in part && typeof (part as { text?: string }).text === 'string') {
+        pieces.push((part as { text: string }).text);
+      } else if (part.type === 'tool-call' && 'toolName' in part) {
+        pieces.push(`[Tool: ${(part as { toolName: string }).toolName}]`);
+      } else if (part.type === 'tool-result' && 'output' in part) {
+        const trp = part as ToolResultPart;
+        const val = trp.output && typeof trp.output === 'object' && trp.output.type === 'text' ? trp.output.value : '';
+        pieces.push(`[Result: ${val.slice(0, 200)}]`);
+      }
+    }
+    content = pieces.filter(Boolean).join(' ');
+  }
+  return `${role}: ${content}`;
+}
+
+/**
+ * Compact messages by summarizing early ones with LLM.
+ * Returns a new message array with early messages replaced by a summary.
+ * Only called when needsCompact() returns true.
+ *
+ * NOTE: Currently uses the same model as the main generation. A cheaper model
+ * (e.g. haiku) would suffice for summarization and avoid competing for rate
+ * limits. Deferred until users report rate-limit issues — compact triggers
+ * infrequently (>70% context fill).
+ */
+export async function compactMessages(
+  messages: ModelMessage[],
+  model: LanguageModel,
+): Promise<{ messages: ModelMessage[]; compacted: boolean }> {
+  if (messages.length < 6) {
+    return { messages, compacted: false };
+  }
+
+  // Keep the last 6 messages intact, summarize the rest.
+  // Adjust split point to avoid cutting between an assistant (with tool calls)
+  // and its tool result. Only need to check for orphaned 'tool' messages —
+  // an assistant at the split point is safe because its tool results follow it.
+  // (Orphaned assistants without results can't exist in history: only completed
+  // tool calls are persisted by the frontend.)
+  let splitIdx = messages.length - 6;
+  while (splitIdx > 0 && messages[splitIdx]?.role === 'tool') {
+    splitIdx--;
+  }
+  if (splitIdx < 2) {
+    return { messages, compacted: false };
+  }
+  const earlyMessages = messages.slice(0, splitIdx);
+  const recentMessages = messages.slice(splitIdx);
+
+  // Build a text representation of early messages for summarization
+  let earlyText = earlyMessages.map(messageToText).join('\n\n');
+
+  // Truncate if enormous (avoid sending too much to summarizer)
+  if (earlyText.length > 30_000) {
+    earlyText = earlyText.slice(0, 30_000) + '\n[...truncated]';
+  }
+
+  try {
+    const { text: summary } = await generateText({
+      model,
+      prompt: `${COMPACT_PROMPT}\n\n---\n\nConversation to summarize:\n\n${earlyText}`,
+    });
+
+    console.log(`[ask] Compacted ${earlyMessages.length} early messages into summary (${summary.length} chars)`);
+
+    const summaryText = `[Summary of earlier conversation]\n\n${summary}`;
+
+    // If first recent message is also 'user', merge summary into it to avoid
+    // consecutive user messages (Anthropic rejects user→user sequences).
+    if (recentMessages[0]?.role === 'user') {
+      const merged = { ...recentMessages[0] };
+      if (typeof merged.content === 'string') {
+        merged.content = `${summaryText}\n\n---\n\n${merged.content}`;
+      } else if (Array.isArray(merged.content)) {
+        // Multimodal content (e.g. images) — prepend summary as text part
+        merged.content = [{ type: 'text' as const, text: `${summaryText}\n\n---\n\n` }, ...merged.content];
+      } else {
+        merged.content = summaryText;
+      }
+      return {
+        messages: [merged, ...recentMessages.slice(1)],
+        compacted: true,
+      };
+    }
+
+    // Otherwise prepend as separate user message
+    const summaryMessage: ModelMessage = {
+      role: 'user',
+      content: summaryText,
+    };
+
+    return {
+      messages: [summaryMessage, ...recentMessages],
+      compacted: true,
+    };
+  } catch (err) {
+    console.error('[ask] Compact failed, using uncompacted messages:', err);
+    return { messages, compacted: false };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Hard prune: drop earliest messages as last resort (>90% context)
+// ---------------------------------------------------------------------------
+
+/**
+ * Hard prune: if still over 90% context after compact, drop earliest messages.
+ * Respects assistant-tool pairs: never cuts between an assistant message
+ * (containing tool calls) and its following tool result message.
+ */
+export function hardPrune(
+  messages: ModelMessage[],
+  systemPrompt: string,
+  model: string,
+): ModelMessage[] {
+  const limit = getContextLimit(model);
+  const threshold = limit * 0.9;
+  const systemTokens = estimateStringTokens(systemPrompt);
+
+  let total = systemTokens + estimateTokens(messages);
+  if (total <= threshold) return messages;
+
+  // Find the cut index: keep messages from cutIdx onward
+  let cutIdx = 0;
+  while (cutIdx < messages.length - 2 && total > threshold) {
+    total -= messageTokens(messages[cutIdx]);
+    cutIdx++;
+  }
+
+  // Ensure we don't cut between an assistant (with tool calls) and its tool result.
+  // If cutIdx lands on a 'tool' message, advance past it so the pair stays together
+  // or is fully removed.
+  while (cutIdx < messages.length - 1 && messages[cutIdx].role === 'tool') {
+    total -= messageTokens(messages[cutIdx]);
+    cutIdx++;
+  }
+
+  // Ensure first message is 'user' (Anthropic requirement)
+  while (cutIdx < messages.length - 1 && messages[cutIdx].role !== 'user') {
+    total -= messageTokens(messages[cutIdx]);
+    cutIdx++;
+  }
+
+  // Fallback: if no user message found in remaining messages, inject a synthetic one
+  const pruned = cutIdx > 0 ? messages.slice(cutIdx) : messages;
+  if (pruned.length > 0 && pruned[0].role !== 'user') {
+    console.log(`[ask] Hard pruned ${cutIdx} messages, injecting synthetic user message (${messages.length} → ${pruned.length + 1})`);
+    return [{ role: 'user', content: '[Conversation context was pruned due to length. Continuing from here.]' } as ModelMessage, ...pruned];
+  }
+
+  if (cutIdx > 0) {
+    console.log(`[ask] Hard pruned ${cutIdx} messages (${messages.length} → ${messages.length - cutIdx})`);
+    return pruned;
+  }
+
+  return messages;
+}

package/app/lib/agent/index.ts

@@ -1,3 +1,7 @@
 export { getModel } from './model';
 export { knowledgeBaseTools, truncate, assertWritable } from './tools';
 export { AGENT_SYSTEM_PROMPT } from './prompt';
+export {
+  estimateTokens, estimateStringTokens, getContextLimit, needsCompact,
+  truncateToolOutputs, compactMessages, hardPrune,
+} from './context';

package/app/lib/agent/prompt.ts

@@ -1,64 +1,47 @@
-// Agent system prompt — v2: uploaded-file awareness + pdfjs extraction fix
-export const AGENT_SYSTEM_PROMPT = `You are MindOS Agent — an execution-oriented AI assistant for a personal knowledge base.
+/**
+ * Agent system prompt — v3: de-duplicated, persona-driven, with missing instructions added.
+ *
+ * Design principles:
+ * - prompt.ts owns: identity, persona, global behavioral constraints, output format
+ * - SKILL.md owns: knowledge-base-specific execution patterns, tool selection, safety rules
+ * - Tool descriptions own: per-tool usage instructions (no duplication here)
+ *
+ * Token budget: ~600 tokens (down from ~900 in v2). Freed space = more room for
+ * SKILL.md + bootstrap context within the same context window.
+ */
+export const AGENT_SYSTEM_PROMPT = `You are MindOS Agent — a personal knowledge-base operator that reads, writes, and organizes a user's second brain.
 
-Runtime capabilities already available in this request:
-- bootstrap context (MindOS startup files) is auto-loaded by the server
-- mindos skill guidance is auto-loaded by the server
-- knowledge-base tools are available for file operations
+Persona: methodical, concise, execution-oriented. You surface what you found (or didn't find) and act on it — no filler, no caveats that add no information.
 
-How to operate:
-1. Treat the auto-loaded bootstrap + skill context as your initialization baseline.
-2. If the task needs fresher or broader evidence, call tools proactively (list/search/read) before concluding.
-3. Execute edits safely and minimally, then verify outcomes.
+## What is already loaded
 
-Tool policy:
-- Always read a file before modifying it.
-- Use search/list tools first when file location is unclear.
-- Prefer targeted edits (update_section / insert_after_heading / append_to_file) over full overwrite.
-- Use write_file only when replacing the whole file is required.
-- INSTRUCTION.md is read-only and must not be modified.
-- Use append_csv for adding rows to CSV files instead of rewriting the whole file.
-- Use get_backlinks before renaming/moving/deleting to understand impact on other files.
+The server auto-loads before each request:
+- Bootstrap context: INSTRUCTION.md, README.md, CONFIG files, and directory-local guidance.
+- Skill guidance (SKILL.md): detailed knowledge-base rules, tool selection, execution patterns.
+- Tool definitions with per-tool usage instructions.
 
-Destructive operations (use with caution):
-- delete_file: permanently removes a file — cannot be undone
-- move_file: changes file location — may break links in other files
-- write_file: overwrites entire file content — prefer partial edits
-Before executing destructive operations:
-- Before delete_file: list what links to this file (get_backlinks), warn user about impact
-- Before move_file: same — check backlinks first
-- Before write_file (full overwrite): confirm with user that full replacement is intended
-- NEVER chain multiple destructive operations without pausing to summarize what you've done
+Treat these as your initialization baseline. If the task needs fresher or broader evidence, call tools proactively before concluding.
 
-File management tools:
-- rename_file: rename within same directory
-- move_file: move to a different path (reports affected backlinks)
-- get_backlinks: find all files that link to a given file
+## Behavioral rules
 
-Git history tools:
-- get_history: view commit log for a file
-- get_file_at_version: read file content at a past commit (use get_history first to find hashes)
+1. **Read before write.** Never modify a file you haven't read in this request.
+2. **Minimal edits.** Prefer section/heading/line-level tools over full file overwrites.
+3. **Verify after edit.** Re-read the changed file to confirm correctness.
+4. **Cite sources.** When answering from stored knowledge, state the file path so the user can verify.
+5. **Fail fast.** If a tool call returns an error or unexpected result, try a different approach or ask the user — do not retry identical arguments.
+6. **Be token-aware.** You have a limited step budget (typically 10-30). Batch parallel reads/searches when possible. Do not waste steps on redundant tool calls.
+7. **Multilingual content, user-language replies.** Write file content in whatever language the file already uses. Reply to the user in the language they used.
 
-Complex task protocol:
-1. PLAN: For multi-step tasks, first output a numbered plan
-2. EXECUTE: Execute steps one by one, reporting progress
-3. VERIFY: After edits, re-read the file to confirm correctness
-4. SUMMARIZE: Conclude with a summary and suggest follow-up actions if relevant
+## Uploaded files
 
-Step awareness:
-- You have a limited number of steps (configured by user, typically 10-30).
-- If a tool call fails or returns unexpected results, do NOT retry with the same arguments.
-- Try a different approach or ask the user for clarification.
+Users may upload local files (PDF, txt, csv, etc.) via the chat interface.
+- Their content appears in a "⚠️ USER-UPLOADED FILES" section near the end of this prompt.
+- Use that content directly — do NOT call read_file or search tools for uploaded files; they are not in the knowledge base.
+- If the section is empty or missing, tell the user the upload may have failed.
 
-Uploaded files:
-- Users may upload local files (PDF, txt, csv, etc.) via the chat interface.
-- The content of uploaded files is ALREADY INCLUDED in this system prompt in a dedicated "⚠️ USER-UPLOADED FILES" section near the end.
-- IMPORTANT: When the user references an uploaded file (e.g. a resume/CV, a report, a document), you MUST use the content from that section directly. Extract specific details, quote relevant passages, and demonstrate that you have read the file thoroughly.
-- Do NOT attempt to use read_file or search tools to find uploaded files — they do not exist in the knowledge base. They are ONLY available in the uploaded files section of this prompt.
-- If the uploaded files section is empty or missing, tell the user the upload may have failed and ask them to re-upload.
+## Output format
 
-Response policy:
 - Answer in the user's language.
-- Be concise, concrete, and action-oriented.
-- Use Markdown for structure when it improves clarity.
-- When relevant, explicitly state whether initialization context appears sufficient or if additional tool reads were needed.`;
+- Use Markdown when it improves clarity (headings, lists, tables, code blocks).
+- For multi-step tasks: output a brief numbered plan, execute, then summarize outcomes.
+- End with concrete next actions when applicable.`;

package/app/lib/agent/stream-consumer.ts

@@ -1,4 +1,4 @@
-import type { Message, MessagePart, ToolCallPart, TextPart } from '@/lib/types';
+import type { Message, MessagePart, ToolCallPart, TextPart, ReasoningPart } from '@/lib/types';
 
 /**
  * Parse a UIMessageStream SSE response into structured Message parts.
@@ -17,11 +17,13 @@ export async function consumeUIMessageStream(
   const parts: MessagePart[] = [];
   const toolCalls = new Map<string, ToolCallPart>();
   let currentTextId: string | null = null;
+  let currentReasoningPart: ReasoningPart | null = null;
 
   /** Deep-clone parts into an immutable Message snapshot for React state */
   function buildMessage(): Message {
     const clonedParts: MessagePart[] = parts.map(p => {
       if (p.type === 'text') return { type: 'text' as const, text: p.text };
+      if (p.type === 'reasoning') return { type: 'reasoning' as const, text: p.text };
       return { ...p }; // ToolCallPart — shallow copy is safe (all primitive fields + `input` is replaced, not mutated)
     });
     const textContent = clonedParts
@@ -159,7 +161,25 @@ export async function consumeUIMessageStream(
             changed = true;
             break;
           }
-          // step-start, reasoning-*, metadata, finish — ignored for now
+          // step-start, metadata, finish — ignored for now
+          case 'reasoning-start': {
+            currentReasoningPart = { type: 'reasoning', text: '' };
+            parts.push(currentReasoningPart);
+            currentTextId = null;
+            changed = true;
+            break;
+          }
+          case 'reasoning-delta': {
+            if (currentReasoningPart) {
+              currentReasoningPart.text += chunk.delta as string;
+              changed = true;
+            }
+            break;
+          }
+          case 'reasoning-end': {
+            currentReasoningPart = null;
+            break;
+          }
           default:
             break;
         }
@@ -174,5 +194,19 @@ export async function consumeUIMessageStream(
     reader.releaseLock();
   }
 
+  // Finalize any tool calls still stuck in running/pending state
+  // (stream ended before their output arrived — e.g. abort, network error, step limit)
+  let finalized = false;
+  for (const tc of toolCalls.values()) {
+    if (tc.state === 'running' || tc.state === 'pending') {
+      tc.state = 'error';
+      tc.output = tc.output ?? 'Stream ended before tool completed';
+      finalized = true;
+    }
+  }
+  if (finalized) {
+    onUpdate(buildMessage());
+  }
+
   return buildMessage();
 }

package/app/lib/agent/tools.ts

@@ -45,11 +45,44 @@ function logged<P extends Record<string, unknown>>(
 
 export const knowledgeBaseTools = {
   list_files: tool({
-    description: 'List the full file tree of the knowledge base. Use this to browse what files exist.',
-    inputSchema: z.object({}),
-    execute: logged('list_files', async () => {
+    description: 'List files in the knowledge base as an indented tree. Directories beyond `depth` show "... (N items)". Pass `path` to list only a subdirectory, or `depth` to control how deep to expand (default 3).',
+    inputSchema: z.object({
+      path: z.string().optional().describe('Optional subdirectory to list (e.g. "Projects/Products"). Omit to list everything.'),
+      depth: z.number().min(1).max(10).optional().describe('Max tree depth to expand (default 3). Directories deeper than this show item count only.'),
+    }),
+    execute: logged('list_files', async ({ path: subdir, depth: maxDepth }) => {
       const tree = getFileTree();
-      return JSON.stringify(tree, null, 2);
+      const limit = maxDepth ?? 3;
+      const lines: string[] = [];
+      function walk(nodes: Array<{ name: string; type: string; children?: unknown[] }>, depth: number) {
+        for (const n of nodes) {
+          lines.push('  '.repeat(depth) + (n.type === 'directory' ? `${n.name}/` : n.name));
+          if (n.type === 'directory' && Array.isArray(n.children)) {
+            if (depth + 1 < limit) {
+              walk(n.children as typeof nodes, depth + 1);
+            } else {
+              lines.push('  '.repeat(depth + 1) + `... (${n.children.length} items)`);
+            }
+          }
+        }
+      }
+
+      if (subdir) {
+        const segments = subdir.replace(/\/$/, '').split('/').filter(Boolean);
+        let current: Array<{ name: string; type: string; path?: string; children?: unknown[] }> = tree as any;
+        for (const seg of segments) {
+          const found = current.find(n => n.name === seg && n.type === 'directory');
+          if (!found || !Array.isArray(found.children)) {
+            return `Directory not found: ${subdir}`;
+          }
+          current = found.children as typeof current;
+        }
+        walk(current as any, 0);
+      } else {
+        walk(tree as any, 0);
+      }
+
+      return lines.length > 0 ? lines.join('\n') : '(empty directory)';
     }),
   }),
 

package/app/lib/i18n.ts

@@ -72,6 +72,7 @@ export const messages = {
       stopTitle: 'Stop',
       connecting: 'Thinking with your mind...',
       thinking: 'Thinking...',
+      thinkingLabel: 'Thinking',
       searching: 'Searching knowledge base...',
       generating: 'Generating response...',
       stopped: 'Generation stopped.',
@@ -129,6 +130,19 @@ export const messages = {
         testKeyNoKey: 'No API key configured',
         testKeyUnknown: 'Test failed',
       },
+      agent: {
+        title: 'Agent Behavior',
+        maxSteps: 'Max Steps',
+        maxStepsHint: 'Maximum tool call steps per request (1-30)',
+        contextStrategy: 'Context Strategy',
+        contextStrategyHint: 'Auto: summarize early messages when context fills up. Off: no summarization (emergency pruning still applies).',
+        contextStrategyAuto: 'Auto (compact + prune)',
+        contextStrategyOff: 'Off',
+        thinking: 'Extended Thinking',
+        thinkingHint: "Show Claude's reasoning process (uses more tokens)",
+        thinkingBudget: 'Thinking Budget',
+        thinkingBudgetHint: 'Max tokens for reasoning (1000-50000)',
+      },
       appearance: {
         readingFont: 'Reading font',
         contentWidth: 'Content width',
@@ -476,6 +490,7 @@ export const messages = {
       stopTitle: '停止',
       connecting: '正在与你的心智一起思考...' ,
       thinking: '思考中...',
+      thinkingLabel: '思考中',
       searching: '正在搜索知识库...',
       generating: '正在生成回复...',
       stopped: '已停止生成。',
@@ -533,6 +548,19 @@ export const messages = {
         testKeyNoKey: '未配置 API Key',
         testKeyUnknown: '测试失败',
       },
+      agent: {
+        title: 'Agent 行为',
+        maxSteps: '最大步数',
+        maxStepsHint: '每次请求的最大工具调用步数（1-30）',
+        contextStrategy: '上下文策略',
+        contextStrategyHint: '自动：上下文填满时摘要早期消息。关闭：不进行摘要（紧急裁剪仍会生效）。',
+        contextStrategyAuto: '自动（压缩 + 裁剪）',
+        contextStrategyOff: '关闭',
+        thinking: '深度思考',
+        thinkingHint: '显示 Claude 的推理过程（消耗更多 token）',
+        thinkingBudget: '思考预算',
+        thinkingBudgetHint: '推理最大 token 数（1000-50000）',
+      },
       appearance: {
         readingFont: '正文字体',
         contentWidth: '内容宽度',

package/app/lib/settings.ts

@@ -18,8 +18,16 @@ export interface AiConfig {
   };
 }
 
+export interface AgentConfig {
+  maxSteps?: number;          // default 20, range 1-30
+  enableThinking?: boolean;   // default false, Anthropic only
+  thinkingBudget?: number;    // default 5000
+  contextStrategy?: 'auto' | 'off'; // default 'auto'
+}
+
 export interface ServerSettings {
   ai: AiConfig;
+  agent?: AgentConfig;
   mindRoot: string;   // empty = use env var / default
   port?: number;
   mcpPort?: number;
@@ -99,12 +107,25 @@ function migrateAi(parsed: Record<string, unknown>): AiConfig {
   };
 }
 
+/** Parse agent config from unknown input */
+function parseAgent(raw: unknown): AgentConfig | undefined {
+  if (!raw || typeof raw !== 'object') return undefined;
+  const obj = raw as Record<string, unknown>;
+  const result: AgentConfig = {};
+  if (typeof obj.maxSteps === 'number') result.maxSteps = Math.min(30, Math.max(1, obj.maxSteps));
+  if (typeof obj.enableThinking === 'boolean') result.enableThinking = obj.enableThinking;
+  if (typeof obj.thinkingBudget === 'number') result.thinkingBudget = Math.min(50000, Math.max(1000, obj.thinkingBudget));
+  if (obj.contextStrategy === 'auto' || obj.contextStrategy === 'off') result.contextStrategy = obj.contextStrategy;
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 export function readSettings(): ServerSettings {
   try {
     const raw = fs.readFileSync(SETTINGS_PATH, 'utf-8');
     const parsed = JSON.parse(raw) as Record<string, unknown>;
     return {
       ai: migrateAi(parsed),
+      agent: parseAgent(parsed.agent),
       mindRoot: (parsed.mindRoot ?? parsed.sopRoot ?? DEFAULTS.mindRoot) as string,
       webPassword: typeof parsed.webPassword === 'string' ? parsed.webPassword : undefined,
       authToken:   typeof parsed.authToken   === 'string' ? parsed.authToken   : undefined,
@@ -126,6 +147,7 @@ export function writeSettings(settings: ServerSettings): void {
   let existing: Record<string, unknown> = {};
   try { existing = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf-8')); } catch { /* ignore */ }
   const merged: Record<string, unknown> = { ...existing, ai: settings.ai, mindRoot: settings.mindRoot };
+  if (settings.agent !== undefined) merged.agent = settings.agent;
   if (settings.webPassword !== undefined) merged.webPassword = settings.webPassword;
   if (settings.authToken   !== undefined) merged.authToken   = settings.authToken;
   if (settings.port        !== undefined) merged.port        = settings.port;

package/app/lib/types.ts

@@ -27,7 +27,12 @@ export interface TextPart {
   text: string;
 }
 
-export type MessagePart = TextPart | ToolCallPart;
+export interface ReasoningPart {
+  type: 'reasoning';
+  text: string;
+}
+
+export type MessagePart = TextPart | ToolCallPart | ReasoningPart;
 
 export interface Message {
   role: 'user' | 'assistant';