@tyvm/knowhow 0.0.144 → 0.0.145

package/src/clients/qwen.ts

@@ -0,0 +1,16 @@
+import { HttpClient } from "./http";
+import { QwenTextPricing } from "./pricing/qwen";
+
+/**
+ * QWEN Cloud client — OpenAI-compatible API
+ * https://dashscope-intl.aliyuncs.com/compatible-mode/v1
+ * Alibaba Cloud's Qwen model family via the international DashScope endpoint.
+ * Set env var QWEN_CLOUD_API_KEY to enable.
+ */
+export class GenericQwenClient extends HttpClient {
+  constructor(apiKey = process.env.QWEN_CLOUD_API_KEY) {
+    super("https://dashscope-intl.aliyuncs.com/compatible-mode/v1");
+    if (apiKey) this.setJwt(apiKey);
+    this.setPrices(QwenTextPricing);
+  }
+}

package/src/clients/types.ts

@@ -8,7 +8,10 @@ export type ModelModality =
 
 export type MessageContent =
   | { type: "text"; text: string }
-  | { type: "image_url"; image_url: { url: string } }
+  | {
+      type: "image_url";
+      image_url: { url: string; detail?: "auto" | "low" | "high" };
+    }
   | { type: "audio_url"; audio_url: { url: string } }
   | { type: "video_url"; video_url: { url: string } };
 
@@ -23,6 +26,50 @@ export interface Message {
 
 export interface OutputMessage extends Message {
   content?: string | null;
+  /**
+   * The model's reasoning/thinking content, when the provider exposes it.
+   * - OpenAI Responses API: a human-readable summary of the model's reasoning
+   *   (populated when reasoning_summary is requested).
+   */
+  reasoning_summary?: string;
+  /**
+   * OpenAI Responses API only (internal): the raw reasoning output items
+   * (carrying encrypted_content) captured from a stateless response. These are
+   * re-injected into the next request's input to preserve the reasoning chain.
+   * Not intended for display.
+   *
+   * @deprecated Prefer the provider-agnostic `_reasoning_details` slot. This is
+   * retained for backward compatibility with the OpenAI client only.
+   */
+  _reasoning_items?: any[];
+  /**
+   * Provider-agnostic (internal): an opaque, provider-tagged carrier for the
+   * model's reasoning artifact that must be round-tripped verbatim on the next
+   * tool-use turn to preserve reasoning continuity. Each provider stashes its
+   * own native artifact here and re-injects it only when the `provider` tag
+   * matches, so provider-specific payload never leaks into the generic
+   * (OpenAI-format) message shape.
+   *
+   *  - openai / xai: Responses API `reasoning` output items (encrypted_content)
+   *  - anthropic:    `thinking` / `redacted_thinking` blocks (with signature/data)
+   *  - gemini:       `thoughtSignature` strings keyed by tool-call id (+ thought parts)
+   *
+   * Not intended for display.
+   */
+  _reasoning_details?: ReasoningDetails;
+}
+
+/**
+ * Opaque, provider-tagged reasoning artifact. The `items` are provider-native
+ * and only meaningful to the client whose id matches `provider`; any other
+ * client must ignore them (they are never mapped into a foreign provider's
+ * request payload).
+ */
+export interface ReasoningDetails {
+  /** The provider that produced these items, e.g. "openai" | "xai" | "anthropic" | "gemini". */
+  provider: string;
+  /** Provider-native reasoning items to round-trip verbatim on the next turn. */
+  items: any[];
 }
 
 export interface ToolProp {
@@ -30,6 +77,7 @@ export interface ToolProp {
   description?: string;
   properties?: { [key: string]: ToolProp };
   items?: ToolProp;
+  enum?: any[];
 }
 
 export interface Tool {
@@ -114,6 +162,20 @@ export interface CompletionOptions extends RetryOptions {
    * Defaults to false (no summary displayed).
    */
   reasoning_summary?: boolean;
+  /**
+   * OpenAI Responses API only: when true, OpenAI stores the response server-side
+   * so subsequent turns can reference it via `previous_response_id` instead of
+   * resending the full reasoning/message history. Defaults to false (stateless).
+   * When false, the client automatically requests `reasoning.encrypted_content`
+   * and threads the reasoning items back in the next request's input.
+   */
+  store?: boolean;
+  /**
+   * OpenAI Responses API only: the id of a previously-stored response to continue
+   * from. Only meaningful when `store` was true on the prior request. When set,
+   * the model keeps its prior chain-of-thought instead of re-deriving it.
+   */
+  previous_response_id?: string;
   /**
    * When true, hints to the client that this task is long-running and it should
    * use a long-TTL cache where available.
@@ -165,6 +227,12 @@ export interface CompletionResponse {
   model: string;
   usage: TokenUsage | undefined;
   usd_cost?: number;
+  /**
+   * OpenAI Responses API only: the id of this response. When `store` was true,
+   * this can be passed as `previous_response_id` on the next request to continue
+   * the reasoning chain without resending history.
+   */
+  response_id?: string;
 }
 
 /** A single chunk yielded by a streaming completion. */

package/src/clients/xai.ts

@@ -116,6 +116,20 @@ export class GenericXAIClient implements GenericClient {
    * Used for grok-4.20 reasoning/non-reasoning and multi-agent models.
    * Translates Chat Completions message format to Responses API format.
    */
+  /**
+   * Resolve the xai-native reasoning items (Responses API `reasoning` items
+   * with encrypted_content) to re-inject for an assistant message, reading the
+   * provider-agnostic `_reasoning_details` slot only when it was produced by
+   * this provider.
+   */
+  private getReasoningItems(msg: any): any[] {
+    const details = msg?._reasoning_details;
+    if (details && details.provider === "xai" && Array.isArray(details.items)) {
+      return details.items;
+    }
+    return [];
+  }
+
   async createChatResponse(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -133,22 +147,46 @@ export class GenericXAIClient implements GenericClient {
       .trim() || undefined;
 
     // Convert chat messages to Responses API input items
+    // Responses API hard limit: 10,485,760 chars per function_call_output.output
+    const MAX_TOOL_OUTPUT = 10_485_000;
+    const truncateToolOutput = (s: string) =>
+      s.length > MAX_TOOL_OUTPUT
+        ? s.slice(0, MAX_TOOL_OUTPUT) + "\n\n[TRUNCATED: output exceeded 10MB API limit]"
+        : s;
     const input: any[] = nonSystemMessages.map((msg) => {
       if (msg.role === "tool") {
         return {
           type: "function_call_output",
           call_id: msg.tool_call_id,
-          output: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+          output: truncateToolOutput(typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)),
         };
       }
       if (msg.role === "assistant" && msg.tool_calls?.length) {
-        return msg.tool_calls.map((tc) => ({
+        // Re-inject any captured reasoning items (encrypted_content) BEFORE the
+        // function_call items so the model keeps its chain-of-thought instead of
+        // re-deriving it from scratch each turn.
+        const reasoningItems = this.getReasoningItems(msg);
+        return [
+          ...reasoningItems,
+          ...msg.tool_calls.map((tc) => ({
           type: "function_call",
           id: tc.id.startsWith("fc") ? tc.id : `fc_${tc.id}`,
           call_id: tc.id,
           name: tc.function.name,
           arguments: tc.function.arguments,
-        }));
+          })),
+        ];
+      }
+      if (msg.role === "assistant" && this.getReasoningItems(msg).length) {
+        // assistant message (no tool calls) that carried reasoning items →
+        // re-inject reasoning items, then the visible message content.
+        return [
+          ...this.getReasoningItems(msg),
+          {
+            role: msg.role,
+            content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+          },
+        ];
       }
       return {
         role: msg.role,
@@ -182,7 +220,18 @@ export class GenericXAIClient implements GenericClient {
       ...(options.max_tokens && { max_output_tokens: Math.max(options.max_tokens, 16_000) }),
       ...(reasoningEffort && { reasoning: { effort: reasoningEffort } }),
       ...(tools?.length && { tools, tool_choice: "auto" }),
-      store: false,
+      // Reasoning persistence (same construct as OpenAI's Responses API):
+      //  - store === true  → xAI persists the response; next turn passes
+      //    previous_response_id to continue the reasoning chain server-side.
+      //  - store !== true  → stateless; request encrypted reasoning content so
+      //    we can thread the reasoning items back into the next request ourselves.
+      store: options.store === true,
+      ...(options.previous_response_id && {
+        previous_response_id: options.previous_response_id,
+      }),
+      ...(options.store !== true && reasoningEffort && {
+        include: ["reasoning.encrypted_content"],
+      }),
     };
 
     const response = await fetch("https://api.x.ai/v1/responses", {
@@ -218,6 +267,10 @@ export class GenericXAIClient implements GenericClient {
     // Collect text content and tool calls from output items
     let textContent: string | null = null;
     const toolCalls: any[] = [];
+    // Reasoning items (with encrypted_content) to thread back into the next
+    // turn, plus a human-readable summary of the model's thinking (if present).
+    const reasoningItems: any[] = [];
+    let reasoningSummary: string | null = null;
 
     for (const item of data.output ?? []) {
       if (item.type === "message") {
@@ -226,6 +279,17 @@ export class GenericXAIClient implements GenericClient {
             textContent = (textContent ?? "") + part.text;
           }
         }
+      } else if (item.type === "reasoning") {
+        // Keep the raw reasoning item so it can be re-injected next turn
+        // (carries encrypted_content when include was requested).
+        reasoningItems.push(item);
+        const summaryParts = item.summary ?? [];
+        for (const part of summaryParts) {
+          const text = typeof part === "string" ? part : part?.text;
+          if (text) {
+            reasoningSummary = (reasoningSummary ?? "") + text;
+          }
+        }
       } else if (item.type === "function_call") {
         toolCalls.push({
           id: item.call_id,
@@ -245,12 +309,17 @@ export class GenericXAIClient implements GenericClient {
             role: "assistant",
             content: textContent,
             ...(toolCalls.length > 0 && { tool_calls: toolCalls }),
+            ...(reasoningSummary && { reasoning_summary: reasoningSummary }),
+            ...(reasoningItems.length > 0 && {
+              _reasoning_details: { provider: "xai", items: reasoningItems },
+            }),
           },
         },
       ],
       model: options.model,
       usage,
       usd_cost: usdCost,
+      response_id: data.id,
     };
   }
 

package/src/commands/agent.ts

@@ -55,6 +55,10 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
     )
     .option("--model <model>", "Specific model for the provider")
     .option("--agent-name <name>", "Which agent to use", "Patcher")
+    .option(
+      "--reasoning-effort <effort>",
+      "Reasoning effort: none, low, medium, or high. Use 'none' to disable thinking on models that support it (e.g. for faster computer-use)."
+    )
     .option(
       "--max-time-limit <minutes>",
       "Time limit for agent execution (minutes)",
@@ -116,17 +120,29 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
             options.taskId,
             options.messageId
           );
+          // Restore the exact model/provider/reasoning the original run used
+          // (falls back to agent defaults when not persisted / remote-only).
+          const savedSettings = await agentModule.loadTaskSettings(
+            options.taskId,
+            options.messageId
+          );
           const resumeInput =
             options.input || "Please continue from where you left off.";
 
           await agentModule.initialize(chatService);
           const { taskCompleted: resumed } =
             await agentModule.resumeFromMessages({
-              agentName: options.agentName || "Patcher",
+              agentName:
+                options.agentName || savedSettings.agentName || "Patcher",
               input: resumeInput,
               threads,
               messageId: options.messageId,
               taskId: options.taskId,
+              // CLI-provided model/provider still win over persisted ones.
+              model: options.model || savedSettings.model,
+              provider: options.provider || savedSettings.provider,
+              reasoningEffort: savedSettings.reasoningEffort,
+              summarizeReasoning: savedSettings.summarizeReasoning,
             });
           await resumed;
           return;
@@ -208,6 +224,9 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
           input,
           maxTimeLimit: parseInt(options.maxTimeLimit, 10),
           maxSpendLimit: parseFloat(options.maxSpendLimit),
+          ...(options.reasoningEffort
+            ? { reasoningEffort: options.reasoningEffort }
+            : {}),
           ...(behaviorSystemPrompt ? { systemPrompt: behaviorSystemPrompt } : {}),
           ...(behaviorModel ? { model: behaviorModel } : {}),
           run: true,

package/src/index.ts

@@ -51,6 +51,14 @@ export {
 } from "./generate";
 
 export * as clients from "./clients";
+export type {
+  Tool,
+  ToolProp,
+  ToolCall,
+  Message,
+  CompletionOptions,
+  CompletionResponse,
+} from "./clients/types";
 export * as agents from "./agents";
 export * as services from "./services";
 export * as embeddings from "./embeddings";
@@ -61,6 +69,7 @@ export * as ai from "./ai";
 // Export module system types for external modules
 export * from "./services/modules/types";
 export { ModulesService } from "./services/modules";
+export * from "./services/modules/computerUse";
 // Export conversion types for external modules (e.g. knowhow-module-pdf)
 export * from "./services/conversion/types";
 export { ConversionService } from "./services/conversion/ConversionService";

package/src/processors/Base64ImageDetector.ts

@@ -257,11 +257,26 @@ export class Base64ImageProcessor {
       try {
         // Try to parse as JSON
         const parsed = JSON.parse(message.content);
-        
-        // Check if it's an image_url object
-        if (parsed.type === "image_url" && parsed.image_url?.url) {
-          // Convert the tool message content from JSON string to an array with the image
-          message.content = [parsed];
+
+        // Normalize the parsed value into an array of candidate parts so we can
+        // handle BOTH shapes a tool might return:
+        //   1. a single image_url object:  {type:"image_url", image_url:{url}}
+        //   2. an array of parts:          [{type:"image_url", image_url:{url}}, {type:"text", ...}]
+        // (Computer-use screenshot tools and loadWebpage return the array form,
+        //  which the single-object check above previously missed — leaving the
+        //  model to see a raw base64 JSON string instead of an actual image.)
+        const candidates = Array.isArray(parsed) ? parsed : [parsed];
+        const isImagePart = (p: any) =>
+          p && p.type === "image_url" && p.image_url?.url;
+        const isTextPart = (p: any) =>
+          p && p.type === "text" && typeof p.text === "string";
+
+        // Only rewrite the content if it actually contains at least one image
+        // part; otherwise leave the original tool text untouched.
+        if (candidates.some(isImagePart)) {
+          message.content = candidates.filter(
+            (p) => isImagePart(p) || isTextPart(p)
+          );
         }
       } catch (e) {
         // Not JSON, check if it's a plain base64 string (only if still a string)
@@ -414,10 +429,34 @@ export class Base64ImageProcessor {
 
       // Read the file as base64
       const imageBuffer = fs.readFileSync(filePath);
+
+      // Detect actual MIME type from magic bytes (overrides extension-based detection)
+      // This handles cases where a file is saved with the wrong extension (e.g. JPEG saved as .png)
+      let detectedMimeType = mimeType;
+      if (imageBuffer.length >= 4) {
+        // JPEG: starts with FF D8 FF
+        if (imageBuffer[0] === 0xff && imageBuffer[1] === 0xd8 && imageBuffer[2] === 0xff) {
+          detectedMimeType = "image/jpeg";
+        }
+        // PNG: starts with 89 50 4E 47 0D 0A 1A 0A
+        else if (imageBuffer[0] === 0x89 && imageBuffer[1] === 0x50 && imageBuffer[2] === 0x4e && imageBuffer[3] === 0x47) {
+          detectedMimeType = "image/png";
+        }
+        // GIF: starts with 47 49 46 38 (GIF8)
+        else if (imageBuffer[0] === 0x47 && imageBuffer[1] === 0x49 && imageBuffer[2] === 0x46 && imageBuffer[3] === 0x38) {
+          detectedMimeType = "image/gif";
+        }
+        // WebP: starts with 52 49 46 46 (RIFF) ... 57 45 42 50 (WEBP) at offset 8
+        else if (imageBuffer.length >= 12 && imageBuffer[0] === 0x52 && imageBuffer[1] === 0x49 && imageBuffer[2] === 0x46 && imageBuffer[3] === 0x46 &&
+                 imageBuffer[8] === 0x57 && imageBuffer[9] === 0x45 && imageBuffer[10] === 0x42 && imageBuffer[11] === 0x50) {
+          detectedMimeType = "image/webp";
+        }
+      }
+
       const base64Data = imageBuffer.toString("base64");
 
-      // Create data URL
-      const dataUrl = `data:${mimeType};base64,${base64Data}`;
+      // Create data URL using the actual detected MIME type
+      const dataUrl = `data:${detectedMimeType};base64,${base64Data}`;
 
       // Return in a format that indicates this is an image
       // The Base64ImageDetector will convert this to proper image content

package/src/processors/GemmaToolProcessor.ts

@@ -0,0 +1,163 @@
+import { Message, ToolCall } from "../clients/types";
+import { MessageProcessorFunction } from "../services/MessageProcessor";
+
+/**
+ * Gemma 4 Tool Call Processor
+ *
+ * Gemma 4 uses a non-standard tool-call format with its own string-quoting token:
+ *
+ *   <|tool_call>call:toolName{key:<|"|>string value<|"|>,numKey:42,boolKey:true}<tool_call|>
+ *
+ * Strings are delimited by <|"|> instead of standard JSON quotes.
+ * Numbers and booleans are written bare (no quotes).
+ * Multiple tool calls may appear in a single assistant message.
+ *
+ * Reference: https://ai.google.dev/gemma/docs/capabilities/text/function-calling-gemma4
+ */
+export class GemmaToolProcessor {
+  private static instance: GemmaToolProcessor;
+
+  static getInstance(): GemmaToolProcessor {
+    if (!GemmaToolProcessor.instance) {
+      GemmaToolProcessor.instance = new GemmaToolProcessor();
+    }
+    return GemmaToolProcessor.instance;
+  }
+
+  // ── Detection ─────────────────────────────────────────────────────────────
+
+  /** Returns true when the content looks like it contains Gemma tool-call tokens. */
+  private isGemmaFormat(content: string): boolean {
+    return content.includes("<|tool_call>") && content.includes("<tool_call|>");
+  }
+
+  // ── Parsing ───────────────────────────────────────────────────────────────
+
+  /**
+   * Cast a raw argument value string to a JS primitive.
+   * Mirrors the Python `cast()` helper from the official docs.
+   */
+  private castValue(raw: string): string | number | boolean {
+    const trimmed = raw.trim();
+
+    // Boolean
+    const lower = trimmed.toLowerCase();
+    if (lower === "true") return true;
+    if (lower === "false") return false;
+
+    // Integer
+    if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+
+    // Float
+    if (/^-?\d+\.\d*$/.test(trimmed)) return parseFloat(trimmed);
+
+    // Strip surrounding single/double quotes that the model might emit
+    return trimmed.replace(/^['"]|['"]$/g, "");
+  }
+
+  /**
+   * Parse the argument body of a single Gemma tool call.
+   *
+   * The body looks like:
+   *   key1:<|"|>string value<|"|>,key2:42,key3:true
+   *
+   * The regex (from the official docs) handles both quoted strings and bare values:
+   *   (\w+):(?:<|"|>(.*?)<|"|>|([^,}]*))
+   */
+  private parseArgs(argsBody: string): Record<string, string | number | boolean> {
+    const result: Record<string, string | number | boolean> = {};
+
+    // Regex from the official Google Gemma 4 function-calling docs
+    const argPattern = /(\w+):(?:<\|"\|>(.*?)<\|"\|>|([^,}]*))/gs;
+    let m: RegExpExecArray | null;
+
+    while ((m = argPattern.exec(argsBody)) !== null) {
+      const key = m[1];
+      // v1: string inside <|"|>…<|"|>   v2: bare value
+      const rawValue = m[2] !== undefined ? m[2] : m[3] ?? "";
+      result[key] = m[2] !== undefined ? rawValue : this.castValue(rawValue);
+    }
+
+    return result;
+  }
+
+  /**
+   * Extract all Gemma tool calls from an assistant message string.
+   * Returns an array of { toolName, arguments } objects.
+   */
+  private extractGemmaToolCalls(
+    content: string
+  ): { toolName: string; arguments: string }[] {
+    const results: { toolName: string; arguments: string }[] = [];
+
+    // Outer pattern: <|tool_call>call:name{args}<tool_call|>
+    // Using DOTALL-equivalent workaround: [\s\S] for multi-line args
+    const outerPattern = /<\|tool_call>call:(\w+)\{([\s\S]*?)\}<tool_call\|>/g;
+    let match: RegExpExecArray | null;
+
+    while ((match = outerPattern.exec(content)) !== null) {
+      const toolName = match[1];
+      const argsBody = match[2];
+
+      const parsed = this.parseArgs(argsBody);
+      results.push({
+        toolName,
+        arguments: JSON.stringify(parsed),
+      });
+    }
+
+    return results;
+  }
+
+  // ── Conversion ────────────────────────────────────────────────────────────
+
+  private generateToolCallId(): string {
+    return `gemma_call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private toToolCalls(
+    extracted: { toolName: string; arguments: string }[]
+  ): ToolCall[] {
+    return extracted.map(({ toolName, arguments: args }) => ({
+      id: this.generateToolCallId(),
+      type: "function" as const,
+      function: {
+        name: toolName,
+        arguments: args,
+      },
+    }));
+  }
+
+  // ── Message processing ────────────────────────────────────────────────────
+
+  private processMessage(message: Message): void {
+    if (message.role !== "assistant") return;
+    if (typeof message.content !== "string") return;
+    if (message?.tool_calls?.length) return;
+
+    if (!this.isGemmaFormat(message.content)) return;
+
+    const extracted = this.extractGemmaToolCalls(message.content);
+    if (extracted.length === 0) return;
+
+    const toolCalls = this.toToolCalls(extracted);
+
+    if (message.tool_calls) {
+      message.tool_calls.push(...toolCalls);
+    } else {
+      message.tool_calls = toolCalls;
+    }
+  }
+
+  // ── Public API ────────────────────────────────────────────────────────────
+
+  createProcessor(): MessageProcessorFunction {
+    return (_originalMessages: Message[], modifiedMessages: Message[]): void => {
+      for (const message of modifiedMessages) {
+        this.processMessage(message);
+      }
+    };
+  }
+}
+
+export const globalGemmaToolProcessor = new GemmaToolProcessor();

package/src/processors/index.ts

@@ -10,4 +10,5 @@ export {
 export { ToolResponseCache } from "./ToolResponseCache";
 export { XmlToolCallProcessor } from "./XmlToolCallProcessor";
 export { HarmonyToolProcessor } from "./HarmonyToolProcessor";
+export { GemmaToolProcessor } from "./GemmaToolProcessor";
 export { MinimalToolsMessageProcessor } from "./MinimalToolsMessageProcessor";

package/src/services/AgentSyncFs.ts

@@ -133,6 +133,11 @@ export class AgentSyncFs {
    * that call) to usage.json. This is intended for debugging cache-hit
    * issues, where comparing the message chains and usage values between
    * consecutive calls can reveal when a cache prefix was invalidated.
+   *
+   * To prevent exponential file growth, if the new entry's message thread
+   * fully contains the previous entry's thread as a prefix, the previous
+   * thread is replaced with { PREV_CACHE_HIT: true } so only the new
+   * messages (the delta) are stored alongside the new usage data.
    */
   private async appendUsageEntry(entry: any): Promise<void> {
     if (!this.taskPath) return;
@@ -148,6 +153,27 @@ export class AgentSyncFs {
         // File doesn't exist or is invalid, start fresh
       }
 
+      // If the new entry's messages are a superset of the last entry's
+      // messages (i.e. the last thread is a prefix of the new thread),
+      // collapse the last entry's messages to { PREV_CACHE_HIT: true }
+      // and store only the new delta — preventing exponential growth.
+      if (entries.length > 0) {
+        const lastEntry = entries[entries.length - 1];
+        const prevMessages: any[] = lastEntry?.messages;
+        const newMessages: any[] = entry?.messages;
+        if (
+          Array.isArray(prevMessages) &&
+          Array.isArray(newMessages) &&
+          prevMessages.length > 0 &&
+          newMessages.length >= prevMessages.length &&
+          JSON.stringify(newMessages.slice(0, prevMessages.length)) ===
+            JSON.stringify(prevMessages)
+        ) {
+          // Replace the previous full thread with a compact sentinel
+          lastEntry.messages = [{ PREV_CACHE_HIT: true }];
+        }
+      }
+
       entries.push(entry);
       await fs.writeFile(usagePath, JSON.stringify(entries, null, 2), "utf8");
     } catch (error) {
@@ -180,6 +206,17 @@ export class AgentSyncFs {
       metadata.totalCostUsd = agent.getTotalCostUsd();
       metadata.tokenUsage = agent.getTokenUsage();
       metadata.agentName = agent.name;
+      // Record the model/provider actually in use at this sync so task
+      // history reflects the real model (including mid-run fallbacks), not
+      // just the named agent.
+      metadata.model = agent.getModel();
+      metadata.provider = agent.getProvider();
+      // Persist reasoning settings so a resume can restore the exact
+      // reasoning effort / summarize behavior the run was using. (The
+      // encrypted reasoning items + summaries themselves ride along on the
+      // thread messages via `_reasoning_details` / `reasoning_summary`.)
+      metadata.reasoningEffort = agent.getReasoningEffort?.();
+      metadata.summarizeReasoning = agent.getSummarizeReasoning?.();
       metadata.inProgress = inProgress;
       metadata.lastUpdate = new Date().toISOString();
 

package/src/services/SessionManager.ts

@@ -65,6 +65,10 @@ export class SessionManager {
         threads,
         currentThread: 0,
         lastUpdated: Date.now(),
+        model: taskInfo.model,
+        provider: taskInfo.provider,
+        reasoningEffort: taskInfo.reasoningEffort,
+        summarizeReasoning: taskInfo.summarizeReasoning,
       };
 
       fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
@@ -101,6 +105,16 @@ export class SessionManager {
           session.knowhowMessageId = taskInfo.knowhowMessageId;
           session.knowhowTaskId = taskInfo.knowhowTaskId;
           session.chatSessionId = taskInfo.chatSessionId;
+
+          // Keep the persisted run configuration in sync (captures mid-run
+          // model/provider fallbacks) so a resume restores the exact setup.
+          if (taskInfo.model !== undefined) session.model = taskInfo.model;
+          if (taskInfo.provider !== undefined)
+            session.provider = taskInfo.provider;
+          if (taskInfo.reasoningEffort !== undefined)
+            session.reasoningEffort = taskInfo.reasoningEffort;
+          if (taskInfo.summarizeReasoning !== undefined)
+            session.summarizeReasoning = taskInfo.summarizeReasoning;
         }
 
         fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2));

package/src/services/Tools.ts

@@ -34,6 +34,8 @@ export interface ToolCallContext {
   caller?: any;
   /** The task id of the calling agent, if known. */
   taskId?: string;
+  /** The task id of the parent agent that spawned the calling agent, if any. */
+  parentTaskId?: string;
   /** Arbitrary additional per-call context. */
   [key: string]: any;
 }
@@ -46,6 +48,7 @@ export interface ToolContext {
   Plugins?: PluginService;
   Mcp?: McpService;
   Behaviors?: BehaviorsService;
+  ComputerUse?: import("./modules/computerUse").ComputerUseService;
   metadata?: { [key: string]: any };
 }