@dotsetlabs/dotclaw 1.3.0 → 1.5.0

package/README.md

@@ -45,6 +45,8 @@ After installation, use the `dotclaw` CLI:
 ```bash
 dotclaw setup        # Full setup (init + configure + build + install service)
 dotclaw configure    # Re-configure API keys and model
+dotclaw add-instance # Create and start an isolated instance
+dotclaw instances    # List discovered instances
 dotclaw build        # Build the Docker container image
 dotclaw start        # Start the service
 dotclaw stop         # Stop the service
@@ -55,6 +57,13 @@ dotclaw doctor       # Run diagnostics
 dotclaw register     # Register a new Telegram chat
 ```
 
+Instance flags:
+
+```bash
+dotclaw status --id dev   # Run against a specific instance (~/.dotclaw-dev)
+dotclaw restart --all     # Restart all instances
+```
+
 ## Configuration
 
 All configuration and data is stored in `~/.dotclaw/`:

package/config-examples/runtime.json

@@ -2,7 +2,8 @@
   "host": {
     "logLevel": "info",
     "container": {
-      "mode": "daemon"
+      "mode": "daemon",
+      "instanceId": ""
     },
     "metrics": {
       "port": 3001,
@@ -20,9 +21,15 @@
       "enabled": true,
       "maxConcurrent": 2,
       "maxRuntimeMs": 2400000,
+      "progress": {
+        "enabled": true,
+        "startDelayMs": 30000,
+        "intervalMs": 120000,
+        "maxUpdates": 3
+      },
       "autoSpawn": {
         "enabled": true,
-        "foregroundTimeoutMs": 180000,
+        "foregroundTimeoutMs": 90000,
         "onTimeout": true,
         "onToolLimit": true,
         "classifier": {
@@ -31,7 +38,89 @@
           "timeoutMs": 3000,
           "maxOutputTokens": 32,
           "temperature": 0,
-          "confidenceThreshold": 0.6
+          "confidenceThreshold": 0.6,
+          "adaptive": {
+            "enabled": true,
+            "minThreshold": 0.55,
+            "maxThreshold": 0.65,
+            "queueDepthLow": 0,
+            "queueDepthHigh": 4
+          }
+        }
+      }
+    },
+    "routing": {
+      "enabled": true,
+      "maxFastChars": 200,
+      "maxStandardChars": 1200,
+      "backgroundMinChars": 2000,
+      "fastKeywords": ["hi", "hello", "hey", "who are you", "what can you do"],
+      "deepKeywords": ["research", "analysis", "report", "dashboard", "refactor", "architecture", "design"],
+      "backgroundKeywords": ["background", "long-running", "research", "dashboard", "refactor", "report"],
+      "classifierFallback": {
+        "enabled": true,
+        "minChars": 600
+      },
+      "plannerProbe": {
+        "enabled": true,
+        "model": "openai/gpt-5-nano",
+        "timeoutMs": 3000,
+        "maxOutputTokens": 120,
+        "temperature": 0,
+        "minChars": 700,
+        "minSteps": 4,
+        "minTools": 3
+      },
+      "profiles": {
+        "fast": {
+          "model": "openai/gpt-5-nano",
+          "maxOutputTokens": 256,
+          "maxToolSteps": 6,
+          "recallMaxResults": 0,
+          "recallMaxTokens": 0,
+          "enablePlanner": false,
+          "enableValidation": false,
+          "responseValidationMaxRetries": 0,
+          "enableMemoryRecall": false,
+          "enableMemoryExtraction": false,
+          "progress": { "enabled": false }
+        },
+        "standard": {
+          "model": "openai/gpt-5-mini",
+          "maxOutputTokens": 768,
+          "maxToolSteps": 16,
+          "recallMaxResults": 6,
+          "recallMaxTokens": 1500,
+          "enablePlanner": true,
+          "enableValidation": true,
+          "responseValidationMaxRetries": 1,
+          "enableMemoryRecall": true,
+          "enableMemoryExtraction": true
+        },
+        "deep": {
+          "model": "moonshotai/kimi-k2.5",
+          "maxOutputTokens": 1536,
+          "maxToolSteps": 32,
+          "recallMaxResults": 12,
+          "recallMaxTokens": 2500,
+          "enablePlanner": true,
+          "enableValidation": true,
+          "responseValidationMaxRetries": 2,
+          "enableMemoryRecall": true,
+          "enableMemoryExtraction": true
+        },
+        "background": {
+          "model": "moonshotai/kimi-k2.5",
+          "maxOutputTokens": 2048,
+          "maxToolSteps": 64,
+          "recallMaxResults": 16,
+          "recallMaxTokens": 4000,
+          "enablePlanner": true,
+          "enableValidation": true,
+          "responseValidationMaxRetries": 2,
+          "enableMemoryRecall": true,
+          "enableMemoryExtraction": true,
+          "progress": { "enabled": true, "initialMs": 15000, "intervalMs": 60000, "maxUpdates": 3 }
         }
       }
     }
@@ -44,6 +133,20 @@
     "planner": {
       "enabled": true,
       "mode": "auto"
+    },
+    "responseValidation": {
+      "enabled": true,
+      "minPromptTokens": 400,
+      "minResponseTokens": 160
+    },
+    "tools": {
+      "progress": {
+        "enabled": true,
+        "minIntervalMs": 30000,
+        "notifyTools": ["WebSearch", "WebFetch", "Bash", "GitClone", "NpmInstall"],
+        "notifyOnStart": true,
+        "notifyOnError": true
+      }
     }
   }
 }

package/container/agent-runner/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "dotclaw-agent-runner",
-  "version": "1.2.0",
+  "version": "1.5.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "dotclaw-agent-runner",
-      "version": "1.2.0",
+      "version": "1.5.0",
       "dependencies": {
         "@openrouter/sdk": "^0.3.0",
         "cron-parser": "^5.0.0",

package/container/agent-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotclaw-agent-runner",
-  "version": "1.2.0",
+  "version": "1.5.0",
   "type": "module",
   "description": "Container-side agent runner for DotClaw",
   "main": "dist/index.js",

package/container/agent-runner/src/agent-config.ts

@@ -60,6 +60,8 @@ export type AgentRuntimeConfig = {
       temperature: number;
       maxRetries: number;
       allowToolCalls: boolean;
+      minPromptTokens: number;
+      minResponseTokens: number;
     };
     tools: {
       maxToolSteps: number;
@@ -87,6 +89,13 @@ export type AgentRuntimeConfig = {
         maxBytes: number;
         httpTimeoutMs: number;
       };
+      progress: {
+        enabled: boolean;
+        minIntervalMs: number;
+        notifyTools: string[];
+        notifyOnStart: boolean;
+        notifyOnError: boolean;
+      };
       toolSummary: {
         enabled: boolean;
         maxBytes: number;
@@ -160,7 +169,7 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
   planner: {
     enabled: true,
     mode: 'auto',
-    minTokens: 600,
+    minTokens: 800,
     triggerRegex: '(plan|steps|roadmap|research|design|architecture|spec|strategy)',
     maxOutputTokens: 200,
     temperature: 0.2
@@ -170,7 +179,9 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
     maxOutputTokens: 120,
     temperature: 0,
     maxRetries: 1,
-    allowToolCalls: false
+    allowToolCalls: false,
+    minPromptTokens: 400,
+    minResponseTokens: 160
   },
   tools: {
     maxToolSteps: 24,
@@ -198,6 +209,13 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
       maxBytes: 800_000,
       httpTimeoutMs: 20_000
     },
+    progress: {
+      enabled: true,
+      minIntervalMs: 30_000,
+      notifyTools: ['WebSearch', 'WebFetch', 'Bash', 'GitClone', 'NpmInstall'],
+      notifyOnStart: true,
+      notifyOnError: true
+    },
     toolSummary: {
       enabled: true,
       maxBytes: 60_000,

package/container/agent-runner/src/container-protocol.ts

@@ -40,6 +40,11 @@ export interface ContainerInput {
   modelContextTokens?: number;
   modelMaxOutputTokens?: number;
   modelTemperature?: number;
+  timezone?: string;
+  disablePlanner?: boolean;
+  disableResponseValidation?: boolean;
+  responseValidationMaxRetries?: number;
+  disableMemoryExtraction?: boolean;
   streaming?: {
     enabled?: boolean;
     draftId?: number;
@@ -63,6 +68,12 @@ export interface ContainerOutput {
   session_recall_count?: number;
   memory_items_upserted?: number;
   memory_items_extracted?: number;
+  timings?: {
+    planner_ms?: number;
+    response_validation_ms?: number;
+    memory_extraction_ms?: number;
+    tool_ms?: number;
+  };
   tool_calls?: Array<{
     name: string;
     args?: unknown;

package/container/agent-runner/src/index.ts

@@ -28,6 +28,8 @@ import {
 } from './memory.js';
 import { loadPromptPackWithCanary, formatTaskExtractionPack, formatResponseQualityPack, formatToolCallingPack, formatToolOutcomePack, formatMemoryPolicyPack, formatMemoryRecallPack, PromptPack } from './prompt-packs.js';
 
+type OpenRouterResult = ReturnType<OpenRouter['callModel']>;
+
 
 const SESSION_ROOT = '/workspace/session';
 const GROUP_DIR = '/workspace/group';
@@ -69,6 +71,89 @@ function log(message: string): void {
   console.error(`[agent-runner] ${message}`);
 }
 
+function coerceTextFromContent(content: unknown): string {
+  if (!content) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map(part => {
+      if (!part) return '';
+      if (typeof part === 'string') return part;
+      if (typeof part === 'object') {
+        const record = part as { text?: unknown; content?: unknown; value?: unknown };
+        if (typeof record.text === 'string') return record.text;
+        if (typeof record.content === 'string') return record.content;
+        if (typeof record.value === 'string') return record.value;
+      }
+      return '';
+    }).join('');
+  }
+  if (typeof content === 'object') {
+    const record = content as { text?: unknown; content?: unknown; value?: unknown };
+    if (typeof record.text === 'string') return record.text;
+    if (typeof record.content === 'string') return record.content;
+    if (typeof record.value === 'string') return record.value;
+  }
+  return '';
+}
+
+function extractTextFallbackFromResponse(response: unknown): string {
+  if (!response || typeof response !== 'object') return '';
+  const record = response as {
+    outputText?: unknown;
+    output_text?: unknown;
+    output?: unknown;
+    choices?: unknown;
+  };
+
+  if (typeof record.outputText === 'string' && record.outputText.trim()) {
+    return record.outputText;
+  }
+  if (typeof record.output_text === 'string' && record.output_text.trim()) {
+    return record.output_text;
+  }
+
+  if (Array.isArray(record.output)) {
+    const messageItem = record.output.find(item => !!item && typeof item === 'object' && (item as { type?: unknown }).type === 'message');
+    if (messageItem && typeof messageItem === 'object') {
+      const content = (messageItem as { content?: unknown }).content;
+      const text = coerceTextFromContent(content);
+      if (text.trim()) return text;
+    }
+  }
+
+  if (Array.isArray(record.choices) && record.choices.length > 0) {
+    const choice = record.choices[0] as { message?: { content?: unknown }; text?: unknown } | null | undefined;
+    if (choice?.message) {
+      const text = coerceTextFromContent(choice.message.content);
+      if (text.trim()) return text;
+    }
+    if (typeof choice?.text === 'string' && choice.text.trim()) {
+      return choice.text;
+    }
+  }
+
+  return '';
+}
+
+async function getTextWithFallback(result: OpenRouterResult, context: string): Promise<string> {
+  const text = await result.getText();
+  if (text && text.trim()) {
+    return text;
+  }
+  try {
+    const response = await result.getResponse();
+    const fallbackText = extractTextFallbackFromResponse(response);
+    if (fallbackText && fallbackText.trim()) {
+      log(`Recovered empty response text from payload (${context})`);
+      return fallbackText;
+    }
+    log(`Model returned empty response and fallback extraction failed (${context})`);
+  } catch (err) {
+    log(`Failed to recover empty response text (${context}): ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return text;
+}
+
 function writeOutput(output: ContainerOutput): void {
   console.log(OUTPUT_START_MARKER);
   console.log(JSON.stringify(output));
@@ -318,6 +403,7 @@ function buildSystemInstructions(params: {
   taskId?: string;
   isBackgroundJob: boolean;
   jobId?: string;
+  timezone?: string;
   planBlock?: string;
   taskExtractionPack?: PromptPack | null;
   responseQualityPack?: PromptPack | null;
@@ -425,6 +511,10 @@ function buildSystemInstructions(params: {
     ? `Behavior overrides:\n${JSON.stringify(params.behaviorConfig, null, 2)}`
     : '';
 
+  const timezoneNote = params.timezone
+    ? `Timezone: ${params.timezone}. Use this timezone when interpreting or presenting timestamps unless the user specifies another.`
+    : '';
+
   const scheduledNote = params.isScheduledTask
     ? `You are running as a scheduled task${params.taskId ? ` (task id: ${params.taskId})` : ''}. If you need to communicate, use \`mcp__dotclaw__send_message\`.`
     : '';
@@ -432,7 +522,7 @@ function buildSystemInstructions(params: {
     ? 'You are running in the background for a user request. Focus on completing the task and return a complete response without asking follow-up questions unless strictly necessary.'
     : '';
   const jobNote = params.isBackgroundJob
-    ? `You are running as a background job${params.jobId ? ` (job id: ${params.jobId})` : ''}. Return a complete result. Use \`mcp__dotclaw__job_update\` for progress if needed. Prefer writing large outputs to the job artifacts directory.`
+    ? `You are running as a background job${params.jobId ? ` (job id: ${params.jobId})` : ''}. Return a complete result. If the task will take more than a few minutes, send periodic \`mcp__dotclaw__job_update\` messages with milestones or intermediate findings (roughly every ~5 minutes or after major steps). Prefer writing large outputs to the job artifacts directory.`
     : '';
   const jobArtifactsNote = params.isBackgroundJob && params.jobId
     ? `Job artifacts directory: /workspace/group/jobs/${params.jobId}`
@@ -496,6 +586,7 @@ function buildSystemInstructions(params: {
     browserAutomation,
     groupNotes,
     globalNotes,
+    timezoneNote,
     params.planBlock || '',
     toolCallingBlock,
     toolOutcomeBlock,
@@ -615,7 +706,7 @@ async function updateMemorySummary(params: {
     maxOutputTokens: params.maxOutputTokens,
     temperature: 0.1
   });
-  const text = await result.getText();
+  const text = await getTextWithFallback(result, 'summary');
   return parseSummaryResponse(text);
 }
 
@@ -756,7 +847,7 @@ async function validateResponseQuality(params: {
     maxOutputTokens: params.maxOutputTokens,
     temperature: params.temperature
   });
-  const text = await result.getText();
+  const text = await getTextWithFallback(result, 'response_validation');
   return parseResponseValidation(text);
 }
 
@@ -835,26 +926,30 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
   const maxToolSteps = Number.isFinite(input.maxToolSteps)
     ? Math.max(1, Math.floor(input.maxToolSteps as number))
     : agent.tools.maxToolSteps;
-  const memoryExtractionEnabled = agent.memory.extraction.enabled;
+  const memoryExtractionEnabled = agent.memory.extraction.enabled && !input.disableMemoryExtraction;
   const isDaemon = process.env.DOTCLAW_DAEMON === '1';
   const memoryExtractionAsync = agent.memory.extraction.async;
   const memoryExtractionMaxMessages = agent.memory.extraction.maxMessages;
   const memoryExtractionMaxOutputTokens = agent.memory.extraction.maxOutputTokens;
   const memoryExtractScheduled = agent.memory.extractScheduled;
   const memoryArchiveSync = agent.memory.archiveSync;
-  const plannerEnabled = agent.planner.enabled;
+  const plannerEnabled = agent.planner.enabled && !input.disablePlanner;
   const plannerMode = String(agent.planner.mode || 'auto').toLowerCase();
   const plannerMinTokens = agent.planner.minTokens;
   const plannerTrigger = buildPlannerTrigger(agent.planner.triggerRegex);
   const plannerModel = agent.models.planner;
   const plannerMaxOutputTokens = agent.planner.maxOutputTokens;
   const plannerTemperature = agent.planner.temperature;
-  const responseValidateEnabled = agent.responseValidation.enabled;
+  const responseValidateEnabled = agent.responseValidation.enabled && !input.disableResponseValidation;
   const responseValidateModel = agent.models.responseValidation;
   const responseValidateMaxOutputTokens = agent.responseValidation.maxOutputTokens;
   const responseValidateTemperature = agent.responseValidation.temperature;
-  const responseValidateMaxRetries = agent.responseValidation.maxRetries;
+  const responseValidateMaxRetries = Number.isFinite(input.responseValidationMaxRetries)
+    ? Math.max(0, Math.floor(input.responseValidationMaxRetries as number))
+    : agent.responseValidation.maxRetries;
   const responseValidateAllowToolCalls = agent.responseValidation.allowToolCalls;
+  const responseValidateMinPromptTokens = agent.responseValidation.minPromptTokens || 0;
+  const responseValidateMinResponseTokens = agent.responseValidation.minResponseTokens || 0;
   const maxContextMessageTokens = agent.context.maxContextMessageTokens;
   const streamingEnabled = Boolean(input.streaming?.enabled && typeof input.streaming?.draftId === 'number');
   const streamingDraftId = streamingEnabled ? input.streaming?.draftId : undefined;
@@ -884,6 +979,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
   const toolCalls: ToolCallRecord[] = [];
   let memoryItemsUpserted = 0;
   let memoryItemsExtracted = 0;
+  const timings: { planner_ms?: number; response_validation_ms?: number; memory_extraction_ms?: number; tool_ms?: number } = {};
   const ipc = createIpcHandlers({
     chatJid: input.chatJid,
     groupFolder: input.groupFolder,
@@ -897,7 +993,11 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     onToolCall: (call) => {
       toolCalls.push(call);
     },
-    policy: input.toolPolicy
+    policy: input.toolPolicy,
+    jobProgress: {
+      jobId: input.jobId,
+      enabled: Boolean(input.isBackgroundJob)
+    }
   });
 
   let streamLastSentAt = 0;
@@ -1083,6 +1183,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     taskId: input.taskId,
     isBackgroundJob: !!input.isBackgroundJob,
     jobId: input.jobId,
+    timezone: typeof input.timezone === 'string' ? input.timezone : undefined,
     planBlock: planBlockValue,
     taskExtractionPack: taskPackResult?.pack || null,
     responseQualityPack: responseQualityResult?.pack || null,
@@ -1109,6 +1210,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     trigger: plannerTrigger
   })) {
     try {
+      const plannerStartedAt = Date.now();
       const plannerPrompt = buildPlannerPrompt(plannerContextMessages);
       const plannerResult = await openrouter.callModel({
         model: plannerModel,
@@ -1117,11 +1219,12 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
         maxOutputTokens: plannerMaxOutputTokens,
         temperature: plannerTemperature
       });
-      const plannerText = await plannerResult.getText();
+      const plannerText = await getTextWithFallback(plannerResult, 'planner');
       const plan = parsePlannerResponse(plannerText);
       if (plan) {
         planBlock = formatPlanBlock(plan);
       }
+      timings.planner_ms = Date.now() - plannerStartedAt;
     } catch (err) {
       log(`Planner failed: ${err instanceof Error ? err.message : String(err)}`);
     }
@@ -1212,7 +1315,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       }
     }
     if (!streamed || !localResponseText || !localResponseText.trim()) {
-      localResponseText = await result.getText();
+      localResponseText = await getTextWithFallback(result, 'completion');
       if (localResponseText && localResponseText.trim()) {
         sendStreamUpdate(localResponseText, true);
       }
@@ -1245,6 +1348,8 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     modelToolCalls = firstAttempt.modelToolCalls;
 
     const shouldValidate = responseValidateEnabled
+      && promptTokens >= responseValidateMinPromptTokens
+      && completionTokens >= responseValidateMinResponseTokens
       && (responseValidateAllowToolCalls || modelToolCalls.length === 0);
     if (shouldValidate) {
       let retriesLeft = responseValidateMaxRetries;
@@ -1257,6 +1362,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
           validationResult = { verdict: 'fail', issues: ['Response was empty.'], missing: [] };
         } else {
           try {
+            const validationStartedAt = Date.now();
             validationResult = await validateResponseQuality({
               openrouter,
               model: responseValidateModel,
@@ -1265,6 +1371,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
               maxOutputTokens: responseValidateMaxOutputTokens,
               temperature: responseValidateTemperature
             });
+            timings.response_validation_ms = (timings.response_validation_ms ?? 0) + (Date.now() - validationStartedAt);
           } catch (err) {
             log(`Response validation failed: ${err instanceof Error ? err.message : String(err)}`);
           }
@@ -1306,6 +1413,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       session_recall_count: sessionRecallCount,
       memory_items_upserted: memoryItemsUpserted,
       memory_items_extracted: memoryItemsExtracted,
+      timings: Object.keys(timings).length > 0 ? timings : undefined,
       tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
       latency_ms: latencyMs
     };
@@ -1335,6 +1443,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
   const runMemoryExtraction = async () => {
     const extractionMessages = history.slice(-memoryExtractionMaxMessages);
     if (extractionMessages.length === 0) return;
+    const extractionStartedAt = Date.now();
     const extractionPrompt = buildMemoryExtractionPrompt({
       assistantName,
       userId: input.userId,
@@ -1349,7 +1458,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       maxOutputTokens: memoryExtractionMaxOutputTokens,
       temperature: 0.1
     });
-    const extractionText = await extractionResult.getText();
+    const extractionText = await getTextWithFallback(extractionResult, 'memory_extraction');
     const extractedItems = parseMemoryExtraction(extractionText);
     if (extractedItems.length === 0) return;
 
@@ -1380,6 +1489,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       memoryItemsExtracted += normalizedItems.length;
       memoryItemsUpserted += normalizedItems.length;
     }
+    timings.memory_extraction_ms = (timings.memory_extraction_ms ?? 0) + (Date.now() - extractionStartedAt);
   };
 
   if (memoryExtractionEnabled && (!input.isScheduledTask || memoryExtractScheduled)) {
@@ -1398,6 +1508,12 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
 
   // Normalize empty/whitespace-only responses to null
   const finalResult = responseText && responseText.trim() ? responseText : null;
+  if (toolCalls.length > 0) {
+    const totalToolMs = toolCalls.reduce((sum, call) => sum + (call.duration_ms || 0), 0);
+    if (totalToolMs > 0) {
+      timings.tool_ms = totalToolMs;
+    }
+  }
 
   return {
     status: 'success',
@@ -1413,6 +1529,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     session_recall_count: sessionRecallCount,
     memory_items_upserted: memoryItemsUpserted,
     memory_items_extracted: memoryItemsExtracted,
+    timings: Object.keys(timings).length > 0 ? timings : undefined,
     tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
     latency_ms: latencyMs
   };