@dotsetlabs/dotclaw 2.6.0 → 2.6.1

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

@@ -54,6 +54,10 @@ import {
   loadImageAttachmentsForInput,
   messagesToOpenRouterInput,
 } from './openrouter-input.js';
+import {
+  extractFunctionCallsForReplay,
+  toReplayFunctionCallItems,
+} from './openrouter-followup.js';
 
 type OpenRouterResult = ReturnType<OpenRouter['callModel']>;
 
@@ -208,21 +212,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));
@@ -1311,7 +1300,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,8 +1419,10 @@ 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 {
             const nudgeResult = openrouter.callModel({
               model: currentModel,
@@ -1448,7 +1439,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 +1579,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, {
@@ -1695,7 +1687,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 +1707,7 @@ export async function runAgentOnce(input: ContainerInput): Promise<ContainerOutp
             writeStreamChunk(followupText);
           }
 
-          pendingCalls = extractFunctionCalls(lastResponse);
+          pendingCalls = extractFunctionCallsForReplay(lastResponse);
         }
 
         if (toolExecutionRequirement.required && toolCalls.length === 0) {

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 || '{}'
+  }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotsetlabs/dotclaw",
-  "version": "2.6.0",
+  "version": "2.6.1",
   "description": "Personal OpenRouter-based assistant. Lightweight, secure, customizable.",
   "type": "module",
   "main": "dist/index.js",