@dotsetlabs/dotclaw 2.6.0 → 2.6.2

package/config-examples/runtime.json

@@ -25,7 +25,8 @@
     },
     "memory": {
       "recall": {
-        "minScore": 0.35
+        "minScore": 0.35,
+        "timeoutMs": 15000
       },
       "embeddings": {
         "enabled": true

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

@@ -1,12 +1,12 @@
 {
   "name": "dotclaw-agent-runner",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "dotclaw-agent-runner",
-      "version": "2.3.0",
+      "version": "2.3.1",
       "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": "2.3.0",
+  "version": "2.3.1",
   "type": "module",
   "description": "Container-side agent runner for DotClaw",
   "main": "dist/index.js",

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

@@ -6,7 +6,7 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { OpenRouter } from '@openrouter/sdk';
+import { OpenRouter, type ResolvedCallModelInput } from '@openrouter/sdk';
 import { createTools, discoverMcpTools, ToolCallRecord, type ToolResultRecord } from './tools.js';
 import { createIpcHandlers } from './ipc.js';
 import { loadAgentConfig } from './agent-config.js';
@@ -53,9 +53,15 @@ import {
   injectImagesIntoContextInput,
   loadImageAttachmentsForInput,
   messagesToOpenRouterInput,
+  sanitizeConversationInputForResponses,
 } from './openrouter-input.js';
+import {
+  extractFunctionCallsForReplay,
+  toReplayFunctionCallItems,
+} from './openrouter-followup.js';
 
 type OpenRouterResult = ReturnType<OpenRouter['callModel']>;
+type OpenRouterResolvedInputArray = Extract<NonNullable<ResolvedCallModelInput['input']>, unknown[]>;
 
 
 const SESSION_ROOT = '/workspace/session';
@@ -208,21 +214,6 @@ function extractTextFromApiResponse(response: any): string {
   return '';
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractFunctionCalls(response: any): Array<{ id: string; name: string; arguments: any }> {
-  const calls: Array<{ id: string; name: string; arguments: unknown }> = [];
-  for (const item of response?.output || []) {
-    if (item?.type === 'function_call') {
-      let args = item.arguments;
-      if (typeof args === 'string') {
-        try { args = JSON.parse(args); } catch { /* keep as string */ }
-      }
-      calls.push({ id: item.callId, name: item.name, arguments: args });
-    }
-  }
-  return calls;
-}
-
 function writeOutput(output: ContainerOutput): void {
   console.log(OUTPUT_START_MARKER);
   console.log(JSON.stringify(output));
@@ -1223,6 +1214,21 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
     }
   };
 
+  const sanitizeConversationInput = (
+    items: unknown[],
+    label: string
+  ): OpenRouterResolvedInputArray => {
+    const sanitized = sanitizeConversationInputForResponses(items);
+    if (sanitized.rewrittenCount > 0 || sanitized.droppedCount > 0) {
+      log(`Sanitized OpenRouter input (${label}): rewritten=${sanitized.rewrittenCount}, dropped=${sanitized.droppedCount}`);
+    }
+    if (sanitized.items.length === 0) {
+      log(`Sanitized OpenRouter input (${label}) produced empty payload; inserting fallback message`);
+      return [{ role: 'user', content: '[No usable conversation context available.]' }] as OpenRouterResolvedInputArray;
+    }
+    return sanitized.items as OpenRouterResolvedInputArray;
+  };
+
   try {
     const { instructions: resolvedInstructions, instructionsTokens: resolvedInstructionTokens, contextMessages } = buildContext();
     // Apply 1.3x safety margin to account for token estimation inaccuracy.
@@ -1244,12 +1250,13 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
       }
     }
 
-    const contextInput = messagesToOpenRouterInput(contextMessages);
+    const rawContextInput = messagesToOpenRouterInput(contextMessages);
 
     // Inject vision content into the last user message if images are present.
     // Uses OpenRouter Responses API content part types (input_text/input_image).
     const imageContent = loadImageAttachmentsForInput(input.attachments, { log });
-    injectImagesIntoContextInput(contextInput, imageContent);
+    injectImagesIntoContextInput(rawContextInput, imageContent);
+    const contextInput: OpenRouterResolvedInputArray = sanitizeConversationInput(rawContextInput, 'context');
 
     let lastError: unknown = null;
     for (let attempt = 0; attempt < modelChain.length; attempt++) {
@@ -1272,11 +1279,11 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
         // We use schema-only tools (no execute functions) so the SDK returns tool calls
         // without auto-executing, then run the loop ourselves with full context.
 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let conversationInput: any[] = [...contextInput];
+        let conversationInput: OpenRouterResolvedInputArray = sanitizeConversationInput([...contextInput], 'initial_conversation');
         let step = 0;
 
         // Initial call — uses streaming for real-time delivery
+        conversationInput = sanitizeConversationInput(conversationInput, `initial_call:${currentModel}`);
         const initialResult = openrouter.callModel({
           model: currentModel,
           instructions: resolvedInstructions,
@@ -1311,7 +1318,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
         }
 
         responseText = extractTextFromApiResponse(lastResponse);
-        let pendingCalls = extractFunctionCalls(lastResponse);
+        let pendingCalls = extractFunctionCallsForReplay(lastResponse);
         const callSignatureCounts = new Map<string, number>();
         let previousRoundSignature = '';
         let repeatedRoundCount = 0;
@@ -1430,9 +1437,12 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
             reason: nudgeReason,
             attempt: toolRequirementNudgeAttempt
           });
-          const responseItems = Array.isArray(lastResponse?.output) ? lastResponse.output : [];
-          conversationInput = [...conversationInput, ...responseItems, { role: 'user', content: nudgePrompt }];
+          if (responseText) {
+            conversationInput = [...conversationInput, { role: 'assistant', content: responseText }];
+          }
+          conversationInput = [...conversationInput, { role: 'user', content: nudgePrompt }];
           try {
+            conversationInput = sanitizeConversationInput(conversationInput, `tool_nudge:${toolRequirementNudgeAttempt}`);
             const nudgeResult = openrouter.callModel({
               model: currentModel,
               instructions: resolvedInstructions,
@@ -1448,7 +1458,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
               responseText = nudgeText;
               writeStreamChunk(nudgeText);
             }
-            pendingCalls = extractFunctionCalls(lastResponse);
+            pendingCalls = extractFunctionCallsForReplay(lastResponse);
           } catch (nudgeErr) {
             log(`Tool requirement nudge failed: ${nudgeErr instanceof Error ? nudgeErr.message : String(nudgeErr)}`);
             break;
@@ -1588,7 +1598,8 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
 
           // Build follow-up input with FULL conversation context:
           // original messages + model output + tool results (accumulated each round)
-          conversationInput = [...conversationInput, ...lastResponse.output, ...toolResults];
+          const replayFunctionCalls = toReplayFunctionCallItems(pendingCalls);
+          conversationInput = [...conversationInput, ...replayFunctionCalls, ...toolResults];
 
           // Compact oversized tool payloads before follow-up calls to reduce context bloat.
           const compactedConversation = compactToolConversationItems(conversationInput, {
@@ -1643,6 +1654,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
           }
 
           // Follow-up call with complete context — model sees the full conversation
+          conversationInput = sanitizeConversationInput(conversationInput, `tool_followup:${step}`);
           const followupResult = openrouter.callModel({
             model: currentModel,
             instructions: resolvedInstructions,
@@ -1680,6 +1692,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
               if (cleared > 0) {
                 log(`Hard-cleared ${cleared} tool results, retrying`);
                 try {
+                  conversationInput = sanitizeConversationInput(conversationInput, `tool_followup_retry:${step}`);
                   const retryResult = openrouter.callModel({
                     model: currentModel,
                     instructions: resolvedInstructions,
@@ -1695,7 +1708,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
                     responseText = retryText;
                     writeStreamChunk(retryText);
                   }
-                  pendingCalls = extractFunctionCalls(lastResponse);
+                  pendingCalls = extractFunctionCallsForReplay(lastResponse);
                   continue;
                 } catch (retryErr) {
                   log(`Context overflow retry failed: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`);
@@ -1715,7 +1728,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
             writeStreamChunk(followupText);
           }
 
-          pendingCalls = extractFunctionCalls(lastResponse);
+          pendingCalls = extractFunctionCallsForReplay(lastResponse);
         }
 
         if (toolExecutionRequirement.required && toolCalls.length === 0) {
@@ -1745,6 +1758,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
           });
           conversationInput = [...conversationInput, { role: 'user', content: continuationPrompt }];
           try {
+            conversationInput = sanitizeConversationInput(conversationInput, `forced_synthesis:${synthesisReason}`);
             const synthesisResult = openrouter.callModel({
               model: currentModel,
               instructions: resolvedInstructions,
@@ -1849,10 +1863,11 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
             keepRecentCount: Math.max(1, toKeep.length)
           }).retryInput;
           try {
+            const sanitizedCompactedInput = sanitizeConversationInput(compactedInput, 'context_overflow_retry');
             const retryResult = openrouter.callModel({
               model: currentModel,
               instructions: minInstructions,
-              input: compactedInput,
+              input: sanitizedCompactedInput,
               tools: schemaTools,
               maxOutputTokens: effectiveMaxOutputTokens,
               temperature: config.temperature,

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

@@ -158,21 +158,121 @@ export function appendHistory(ctx: SessionContext, role: 'user' | 'assistant', c
   return message;
 }
 
+function safeStringifyHistoryValue(value: unknown): string {
+  try {
+    const serialized = JSON.stringify(value);
+    return typeof serialized === 'string' ? serialized : String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function coerceHistoryContentToString(value: unknown): string {
+  if (typeof value === 'string') return value;
+  if (value == null) return '';
+
+  if (Array.isArray(value)) {
+    const parts = value
+      .map((part) => {
+        if (!part || typeof part !== 'object') return null;
+        const record = part as Record<string, unknown>;
+        if (typeof record.text === 'string' && record.text.trim()) return record.text;
+        if (typeof record.content === 'string' && record.content.trim()) return record.content;
+        if (typeof record.output === 'string' && record.output.trim()) return record.output;
+        if (typeof record.refusal === 'string' && record.refusal.trim()) return record.refusal;
+        return null;
+      })
+      .filter((part): part is string => typeof part === 'string');
+    if (parts.length > 0) return parts.join('\n');
+    return safeStringifyHistoryValue(value);
+  }
+
+  if (typeof value === 'object') {
+    const record = value as Record<string, unknown>;
+    if (typeof record.text === 'string' && record.text.trim()) return record.text;
+    if (typeof record.content === 'string' && record.content.trim()) return record.content;
+    if (typeof record.output === 'string' && record.output.trim()) return record.output;
+    if (typeof record.refusal === 'string' && record.refusal.trim()) return record.refusal;
+    return safeStringifyHistoryValue(value);
+  }
+
+  return String(value);
+}
+
 export function loadHistory(ctx: SessionContext): Message[] {
   if (!fs.existsSync(ctx.historyPath)) return [];
-  const lines = fs.readFileSync(ctx.historyPath, 'utf-8').trim().split('\n');
+  const raw = fs.readFileSync(ctx.historyPath, 'utf-8');
+  if (!raw.trim()) return [];
+  const lines = raw.trim().split('\n');
   const messages: Message[] = [];
+  let needsRewrite = false;
+  let highestSeq = 0;
   for (const line of lines) {
-    if (!line.trim()) continue;
+    if (!line.trim()) {
+      needsRewrite = true;
+      continue;
+    }
     try {
-      const parsed = JSON.parse(line);
-      if (parsed?.role && parsed?.content) {
-        messages.push(parsed);
+      const parsed = JSON.parse(line) as Record<string, unknown>;
+      const role = parsed?.role === 'user' || parsed?.role === 'assistant'
+        ? parsed.role
+        : null;
+      if (!role) {
+        needsRewrite = true;
+        continue;
+      }
+
+      const content = coerceHistoryContentToString(parsed.content);
+      if (typeof parsed.content !== 'string') {
+        needsRewrite = true;
+      }
+
+      const timestamp = typeof parsed.timestamp === 'string' && parsed.timestamp
+        ? parsed.timestamp
+        : new Date().toISOString();
+      if (timestamp !== parsed.timestamp) {
+        needsRewrite = true;
       }
+
+      const parsedSeq = Number(parsed.seq);
+      const seq = Number.isFinite(parsedSeq) && parsedSeq > 0
+        ? Math.floor(parsedSeq)
+        : (highestSeq + 1);
+      if (seq !== parsedSeq) {
+        needsRewrite = true;
+      }
+      highestSeq = Math.max(highestSeq, seq);
+
+      messages.push({
+        role,
+        content,
+        timestamp,
+        seq
+      });
     } catch {
-      // ignore malformed lines
+      needsRewrite = true;
     }
   }
+
+  messages.sort((a, b) => a.seq - b.seq);
+  let nextSeq = 1;
+  for (const message of messages) {
+    if (message.seq < nextSeq) {
+      message.seq = nextSeq;
+      needsRewrite = true;
+    }
+    nextSeq = message.seq + 1;
+  }
+
+  if (ctx.meta.nextSeq < nextSeq) {
+    ctx.meta.nextSeq = nextSeq;
+    saveSessionMeta(ctx);
+  }
+
+  if (needsRewrite) {
+    writeHistory(ctx, messages);
+  }
+
   return messages;
 }
 

package/container/agent-runner/src/openrouter-followup.ts

@@ -0,0 +1,87 @@
+type RawRecord = Record<string, unknown>;
+
+export type ExtractedFunctionCall = {
+  id: string;
+  itemId?: string;
+  name: string;
+  arguments: unknown;
+  argumentsText: string;
+};
+
+export type ReplayFunctionCallItem = {
+  type: 'function_call';
+  id: string;
+  callId: string;
+  name: string;
+  arguments: string;
+};
+
+function normalizeCallId(record: RawRecord): { callId?: string; itemId?: string } {
+  const callId = typeof record.callId === 'string' && record.callId.trim()
+    ? record.callId.trim()
+    : (typeof record.id === 'string' && record.id.trim() ? record.id.trim() : undefined);
+  const itemId = typeof record.id === 'string' && record.id.trim()
+    ? record.id.trim()
+    : undefined;
+  return { callId, itemId };
+}
+
+function normalizeArguments(raw: unknown): { arguments: unknown; argumentsText: string } {
+  if (typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (!trimmed) return { arguments: {}, argumentsText: '{}' };
+    try {
+      return { arguments: JSON.parse(trimmed), argumentsText: trimmed };
+    } catch {
+      return { arguments: raw, argumentsText: raw };
+    }
+  }
+  if (raw == null) return { arguments: {}, argumentsText: '{}' };
+  try {
+    const serialized = JSON.stringify(raw);
+    if (typeof serialized === 'string') {
+      return { arguments: raw, argumentsText: serialized };
+    }
+  } catch {
+    // fall through
+  }
+  return { arguments: raw, argumentsText: String(raw) };
+}
+
+function extractFromOutput(output: unknown[]): ExtractedFunctionCall[] {
+  const calls: ExtractedFunctionCall[] = [];
+  for (const item of output) {
+    if (!item || typeof item !== 'object') continue;
+    const record = item as RawRecord;
+    if (record.type !== 'function_call') continue;
+    const { callId, itemId } = normalizeCallId(record);
+    const name = typeof record.name === 'string' ? record.name.trim() : '';
+    if (!callId || !name) continue;
+    const normalizedArguments = normalizeArguments(record.arguments);
+    calls.push({
+      id: callId,
+      itemId,
+      name,
+      arguments: normalizedArguments.arguments,
+      argumentsText: normalizedArguments.argumentsText
+    });
+  }
+  return calls;
+}
+
+export function extractFunctionCallsForReplay(response: unknown): ExtractedFunctionCall[] {
+  if (!response || typeof response !== 'object') return [];
+  const output = (response as { output?: unknown }).output;
+  if (!Array.isArray(output)) return [];
+  return extractFromOutput(output);
+}
+
+export function toReplayFunctionCallItems(calls: ExtractedFunctionCall[]): ReplayFunctionCallItem[] {
+  return calls.map((call) => ({
+    type: 'function_call',
+    id: call.itemId || call.id,
+    callId: call.id,
+    name: call.name,
+    arguments: call.argumentsText || '{}'
+  }));
+}