@tyvm/knowhow 0.0.144 → 0.0.145

package/src/chat/modules/AgentModule.ts

@@ -27,6 +27,7 @@ import {
   CustomVariables,
   XmlToolCallProcessor,
   HarmonyToolProcessor,
+  GemmaToolProcessor,
   Base64ImageProcessor,
   MinimalToolsMessageProcessor,
 } from "../../processors/index";
@@ -339,7 +340,34 @@ export class AgentModule extends BaseChatModule {
       }
     );
 
-    await this.handleAgentCommand(["Patcher"]);
+    // Determine the default agent from context (set by chat.ts from config.chat.defaultAgent)
+    // falling back to "Patcher" if not configured.
+    const context = this.chatService?.getContext();
+    const defaultAgentName = context?.defaultAgent ?? "Patcher";
+    await this.handleAgentCommand([defaultAgentName]);
+
+    // Apply defaultModel and defaultProvider if configured
+    const defaultModel = context?.defaultModel;
+    const defaultProvider = context?.defaultProvider;
+    if (defaultModel || defaultProvider) {
+      const selectedAgent = context?.selectedAgent;
+      if (selectedAgent) {
+        if (defaultModel) {
+          selectedAgent.setModel(defaultModel);
+          selectedAgent.setModelPreferences([
+            { model: defaultModel, provider: defaultProvider as any },
+          ]);
+        }
+        if (defaultProvider) {
+          selectedAgent.setProvider(defaultProvider as any);
+        }
+        // Refresh context model/provider display
+        if (context) {
+          if (defaultModel) context.currentModel = defaultModel;
+          if (defaultProvider) context.currentProvider = defaultProvider;
+        }
+      }
+    }
   }
 
   async handleAgentCommand(args: string[]): Promise<void> {
@@ -682,6 +710,11 @@ export class AgentModule extends BaseChatModule {
         messageId: session.knowhowMessageId,
         chatHistory: [],
         run: false, // Don't run yet, we need to set up event listeners first
+        // Restore the exact model/provider/reasoning the original run used.
+        model: session.model,
+        provider: session.provider,
+        reasoningEffort: session.reasoningEffort,
+        summarizeReasoning: session.summarizeReasoning,
       });
 
       // After resume finishes, revert to normal chat (non-agent mode) so the
@@ -758,6 +791,10 @@ export class AgentModule extends BaseChatModule {
     run?: boolean; // whether to run immediately
     taskId?: string; // optional pre-generated taskId
     parentTaskId?: string; // taskId of the parent agent that spawned this task
+    // Reasoning settings to restore (e.g. on resume). When provided these take
+    // precedence over the module-level CLI defaults.
+    reasoningEffort?: CompletionOptions["reasoning_effort"];
+    summarizeReasoning?: boolean;
   }) {
     const { input, chatHistory = [], agentName } = options;
     const agentContext = services().Agents.getAgentContext();
@@ -841,8 +878,15 @@ export class AgentModule extends BaseChatModule {
 
       // Set up session update listener
       const threadUpdateHandler = async (threadState: any) => {
-        this.updateSession(taskId, agent.getThreads());
         taskInfo.totalCost = agent.getTotalCostUsd();
+        // Capture the live run configuration so it's persisted for an exact
+        // resume (including mid-run model/provider fallbacks).
+        taskInfo.model = agent.getModel();
+        taskInfo.provider = agent.getProvider();
+        taskInfo.reasoningEffort = agent.getReasoningEffort?.();
+        taskInfo.summarizeReasoning = agent.getSummarizeReasoning?.();
+        // updateSession pulls the (mutated) taskInfo from the registry.
+        this.updateSession(taskId, agent.getThreads());
       };
       agent.agentEvents.on(agent.eventTypes.threadUpdate, threadUpdateHandler);
 
@@ -854,6 +898,13 @@ export class AgentModule extends BaseChatModule {
       // Initialize new task
       await agent.newTask(taskId);
 
+      // Record the parent task id on the agent so self-referential tools
+      // (e.g. replyToParent) can resolve who spawned this agent without
+      // relying solely on reading metadata.json off disk.
+      if (options.parentTaskId) {
+        agent.setParentTaskId(options.parentTaskId);
+      }
+
       if (options.model) {
         console.log("Setting model:", options.model);
         agent.setModel(options.model);
@@ -862,11 +913,28 @@ export class AgentModule extends BaseChatModule {
         ]);
       }
 
-      // Apply module-level reasoning settings to the agent
-      if (this.reasoningEffort !== undefined) {
-        agent.setReasoningEffort(this.reasoningEffort);
+      // Restore the provider explicitly (e.g. on resume) so the agent talks to
+      // the same client the original run used, not the model's default provider.
+      if (options.provider) {
+        agent.setProvider(options.provider as any);
       }
-      agent.setSummarizeReasoning(this.summarizeReasoning);
+
+      // Apply reasoning settings to the agent. Explicit per-task settings
+      // (e.g. restored from a resumed task's metadata) take precedence over
+      // the module-level CLI defaults so a /resume keeps the same reasoning
+      // effort the original run used.
+      const effectiveReasoningEffort =
+        options.reasoningEffort !== undefined
+          ? options.reasoningEffort
+          : this.reasoningEffort;
+      if (effectiveReasoningEffort !== undefined) {
+        agent.setReasoningEffort(effectiveReasoningEffort);
+      }
+      agent.setSummarizeReasoning(
+        options.summarizeReasoning !== undefined
+          ? options.summarizeReasoning
+          : this.summarizeReasoning
+      );
 
       // Set up message processors like in original startAgent
 
@@ -908,6 +976,7 @@ export class AgentModule extends BaseChatModule {
       agent.messageProcessor.setProcessors("post_call", [
         new XmlToolCallProcessor().createProcessor(),
         new HarmonyToolProcessor().createProcessor(),
+        new GemmaToolProcessor().createProcessor(),
       ]);
 
       agent.messageProcessor.setProcessors("pre_tools", [
@@ -1118,6 +1187,50 @@ export class AgentModule extends BaseChatModule {
     return threads;
   }
 
+  /**
+   * Load the persisted run settings (model / provider / reasoning) for a task
+   * from local FS metadata, so a headless --resume can restore the exact
+   * configuration the original run used instead of falling back to agent
+   * defaults. Returns an empty object when no local metadata is found (e.g.
+   * remote-only tasks).
+   */
+  public async loadTaskSettings(
+    taskId: string,
+    messageId?: string
+  ): Promise<{
+    model?: string;
+    provider?: string;
+    reasoningEffort?: CompletionOptions["reasoning_effort"];
+    summarizeReasoning?: boolean;
+    agentName?: string;
+  }> {
+    const localMetadataPath = path.join(
+      ".knowhow",
+      "processes",
+      "agents",
+      taskId,
+      "metadata.json"
+    );
+
+    if (!messageId && fs.existsSync(localMetadataPath)) {
+      try {
+        const raw = await fsPromises.readFile(localMetadataPath, "utf-8");
+        const metadata = JSON.parse(raw);
+        return {
+          model: metadata.model,
+          provider: metadata.provider,
+          reasoningEffort: metadata.reasoningEffort,
+          summarizeReasoning: metadata.summarizeReasoning,
+          agentName: metadata.agentName,
+        };
+      } catch (e) {
+        console.warn(`⚠️ Failed to parse local metadata for settings: ${e.message}`);
+      }
+    }
+
+    return {};
+  }
+
   /**
    * Resume an agent from a set of existing message threads
    * Used by the CLI --resume flag to continue crashed/failed tasks
@@ -1129,6 +1242,11 @@ export class AgentModule extends BaseChatModule {
     messageId?: string;
     taskId?: string;
     interactive?: boolean;
+    // Restore the exact model/provider/reasoning the original run used.
+    model?: string;
+    provider?: string;
+    reasoningEffort?: CompletionOptions["reasoning_effort"];
+    summarizeReasoning?: boolean;
   }): Promise<{ taskCompleted: Promise<string> }> {
     const { agentName, input, threads, messageId, taskId } = options;
 
@@ -1189,6 +1307,11 @@ export class AgentModule extends BaseChatModule {
       // remote task identified by taskId.
       syncRemote: !messageId && !!taskId,
       run: false,
+      // Restore the model/provider/reasoning captured from the task metadata.
+      model: options.model,
+      provider: options.provider,
+      reasoningEffort: options.reasoningEffort,
+      summarizeReasoning: options.summarizeReasoning,
     });
 
     // Interactive (chat REPL) resume: route through the attached chat loop so the

package/src/chat/modules/SessionsModule.ts

@@ -396,6 +396,12 @@ export class SessionsModule extends BaseChatModule {
             threads: normalizedThreads,
             input: additionalContext?.trim() || initialInput || "",
             interactive: true,
+            // Restore the exact model/provider/reasoning the run used so
+            // resuming doesn't silently drop back to agent defaults.
+            model: metadata.model,
+            provider: metadata.provider,
+            reasoningEffort: metadata.reasoningEffort,
+            summarizeReasoning: metadata.summarizeReasoning,
           });
           return;
         } catch (e: any) {

package/src/chat/types.ts

@@ -10,6 +10,9 @@ export interface ChatContext {
   debugMode?: boolean;
   agentMode?: boolean;
   currentAgent?: string;
+  defaultAgent?: string;
+  defaultModel?: string;
+  defaultProvider?: string;
   promptText?: string;
   searchMode?: boolean;
   voiceMode?: boolean;
@@ -94,6 +97,12 @@ export interface TaskInfo {
   endTime?: number;
   totalCost: number;
   sessionFile?: string;
+  // Model/provider/reasoning actually used for this run, so a resume can
+  // restore the exact configuration instead of falling back to agent defaults.
+  model?: string;
+  provider?: string;
+  reasoningEffort?: "none" | "low" | "medium" | "high";
+  summarizeReasoning?: boolean;
 }
 
 export interface ChatSession {
@@ -111,6 +120,11 @@ export interface ChatSession {
   threads: any[][];
   currentThread: number;
   lastUpdated: number;
+  // Persisted run configuration for exact resume restoration.
+  model?: string;
+  provider?: string;
+  reasoningEffort?: "none" | "low" | "medium" | "high";
+  summarizeReasoning?: boolean;
 }
 
 export interface ChatHistory {

package/src/chat.ts

@@ -54,6 +54,17 @@ async function main(initialCommand?: string) {
     // Create chat service with plugins
     const chatService = new CliChatService(config.plugins?.enabled ?? []);
 
+    // ── Default Agent / Model / Provider ──────────────────────────────────────
+    // If chat config specifies defaults, inject them into the context so
+    // AgentModule can pick them up during initialize().
+    if (config.chat?.defaultAgent || config.chat?.defaultModel || config.chat?.defaultProvider) {
+      chatService.setContext({
+        defaultAgent: config.chat?.defaultAgent,
+        defaultModel: config.chat?.defaultModel,
+        defaultProvider: config.chat?.defaultProvider,
+      });
+    }
+
     // ── Renderer ──────────────────────────────────────────────────────────────
     // Load a custom renderer if configured, otherwise use the default
     // ConsoleRenderer (already the default inside AgentModule).

package/src/cli.ts

@@ -157,6 +157,8 @@ async function main() {
   await program.parseAsync(process.argv);
 }
 
+export { main };
+
 if (require.main === module) {
   main()
     .catch((e) => {

package/src/clients/anthropic.ts

@@ -245,6 +245,18 @@ export class GenericAnthropicClient implements GenericClient {
 
   transformMessages(messages: Message[], longTtl = false): MessageParam[] {
     const toolCalls = messages.flatMap((msg) => msg.tool_calls || []);
+    // Map each tool_call id → the thinking blocks captured on the assistant
+    // message that produced it, so we can re-inject them before the tool_use.
+    const thinkingByCallId: { [id: string]: any[] } = {};
+    for (const m of messages) {
+      if (m.role !== "assistant" || !m.tool_calls?.length) continue;
+      const details = (m as any)._reasoning_details;
+      if (details?.provider === "anthropic" && Array.isArray(details.items)) {
+        // Attach to the FIRST tool_call of this assistant turn (thinking blocks
+        // must precede the first tool_use in the turn).
+        thinkingByCallId[m.tool_calls[0].id] = details.items;
+      }
+    }
     const claudeMessages: MessageParam[] = messages
       .filter((msg) => msg.role !== "system")
       .filter((msg) => msg.content || msg.role === "tool")
@@ -258,9 +270,14 @@ export class GenericAnthropicClient implements GenericClient {
               JSON.stringify(msg, null, 2)
             );
           } else {
+            // Re-inject any captured thinking / redacted_thinking blocks
+            // (verbatim, with signature/data) BEFORE the tool_use block, as
+            // Anthropic requires for reasoning continuity across tool turns.
+            const thinkingBlocks = thinkingByCallId[msg.tool_call_id] ?? [];
             toolMessages.push({
               role: "assistant",
               content: [
+                ...thinkingBlocks,
                 {
                   type: "tool_use",
                   id: msg.tool_call_id,
@@ -440,8 +457,42 @@ export class GenericAnthropicClient implements GenericClient {
         console.log("no content in Anthropic response", response);
       }
 
+      // Capture thinking / redacted_thinking blocks verbatim (with their
+      // signature / data) so they can be round-tripped unmodified on the next
+      // tool-use turn. Anthropic REQUIRES thinking blocks from the assistant
+      // message to be passed back, complete and unmodified, when returning tool
+      // results — otherwise reasoning continuity and prompt-cache hits are lost.
+      const thinkingBlocks = response.content.filter(
+        (c) => c.type === "thinking" || c.type === "redacted_thinking"
+      );
+      const reasoningDetails =
+        thinkingBlocks.length > 0
+          ? { provider: "anthropic", items: thinkingBlocks }
+          : undefined;
+      // Extract a human-readable summary from thinking blocks (when present).
+      const reasoningSummary = thinkingBlocks
+        .map((b) => ("thinking" in b ? (b as any).thinking : ""))
+        .filter(Boolean)
+        .join("\n") || undefined;
+
+      // Determine which resulting choice should carry the thinking blocks. They
+      // are re-injected before the first tool_use on the next turn, so prefer
+      // the first tool_use block; if there are no tool calls, fall back to the
+      // first (text) block. This keeps a single copy that transformMessages can
+      // reliably find via the assistant message's tool_calls.
+      const nonThinking = response.content.filter(
+        (c) => c.type !== "thinking" && c.type !== "redacted_thinking"
+      );
+      const firstToolUseIdx = nonThinking.findIndex((c) => c.type === "tool_use");
+      const carryIdx = firstToolUseIdx >= 0 ? firstToolUseIdx : 0;
+
       return {
-        choices: response.content.map((c) => {
+        choices: nonThinking.map((c, idx) => {
+            // Only the FIRST resulting assistant message carries the thinking
+            // blocks (Anthropic requires a single thinking block sequence at the
+            // start of the assistant turn); attaching to every choice would
+            // duplicate them once the messages are re-transformed.
+            const carryReasoning = idx === carryIdx;
           if (c.type === "tool_use") {
             return {
               message: {
@@ -457,6 +508,8 @@ export class GenericAnthropicClient implements GenericClient {
                     },
                   },
                 ],
+                ...(carryReasoning && reasoningDetails && { _reasoning_details: reasoningDetails }),
+                ...(carryReasoning && reasoningSummary && { reasoning_summary: reasoningSummary }),
               },
             };
           } else {
@@ -465,6 +518,8 @@ export class GenericAnthropicClient implements GenericClient {
                 role: "assistant",
                 content: "text" in c ? c.text : c.type,
                 tool_calls: [],
+                ...(carryReasoning && reasoningDetails && { _reasoning_details: reasoningDetails }),
+                ...(carryReasoning && reasoningSummary && { reasoning_summary: reasoningSummary }),
               },
             };
           }

package/src/clients/contextLimits.ts

@@ -1,4 +1,5 @@
 import { Models, EmbeddingModels } from "../types";
+import { FireworksModels } from "./pricing/fireworks";
 
 /**
  * Context window limits (in tokens) for all supported models.
@@ -207,6 +208,45 @@ export const ContextLimits: Record<string, number> = {
   [Models.xai.GrokImagineImage]: 0,
   [Models.xai.GrokImagineVideo]: 0,
   [Models.xai.Grok2Image1212]: 0,
+
+  // ─── Fireworks AI ──────────────────────────────────────────────────────────
+  // Moonshot AI (Kimi) — context windows per fireworks.ai/pricing
+  [FireworksModels.KimiK3]:       131_072,
+  [FireworksModels.KimiK2p7Code]: 131_072,
+  [FireworksModels.KimiK2_6]:     131_072,
+  [FireworksModels.KimiK2_5]:     131_072,
+
+  // MiniMax
+  [FireworksModels.MinimaxM3]:    1_000_000,
+  [FireworksModels.MinimaxM2_7]:  1_000_000,
+  [FireworksModels.MinimaxM2_5]:  1_000_000,
+
+  // Qwen
+  [FireworksModels.Qwen3p7Plus]:  131_072,
+  [FireworksModels.Qwen3_6Plus]:  131_072,
+  [FireworksModels.Qwen3p6Plus]:  131_072,
+  [FireworksModels.Qwen3Vl30bA3bThinking]: 32_768,
+  [FireworksModels.Qwen3Vl30bA3bInstruct]: 32_768,
+  [FireworksModels.Qwen3_8b]:     131_072,
+
+  // Z.ai (GLM)
+  [FireworksModels.Glm5p2]: 131_072,
+  [FireworksModels.Glm5p1]: 131_072,
+  [FireworksModels.Glm5]:   131_072,
+  [FireworksModels.Glm4_7]: 131_072,
+
+  // DeepSeek AI
+  [FireworksModels.DeepseekV4Pro]:   163_840,
+  [FireworksModels.DeepseekV4Flash]: 163_840,
+  [FireworksModels.DeepseekV3_2]:    163_840,
+  [FireworksModels.DeepseekV3_1]:    163_840,
+
+  // OpenAI OSS
+  [FireworksModels.GptOss120b]: 131_072,
+
+  // Fireworks embedding/reranker models — 40k context
+  [FireworksModels.Qwen3Embedding8b]: 40_960,
+  [FireworksModels.Qwen3Reranker8b]:  40_960,
 };
 
 /** Default fallback context window limit (tokens) used when a model is not found. */

package/src/clients/gemini.ts

@@ -225,17 +225,44 @@ export class GenericGeminiClient implements GenericClient {
           msg.tool_calls &&
           msg.tool_calls.length > 0
         ) {
+          // Look up any captured thoughtSignatures for this assistant message so
+          // we can re-attach them to the matching functionCall part (required by
+          // Gemini 3 to preserve reasoning continuity across tool-use turns).
+          const details = (msg as any)._reasoning_details;
+          const sigByCallId: { [id: string]: string } = {};
+          const standaloneThoughtSigs: string[] = [];
+          if (details && details.provider === "gemini" && Array.isArray(details.items)) {
+            for (const item of details.items) {
+              if (item?.kind === "functionCall" && item.callId) {
+                sigByCallId[item.callId] = item.thoughtSignature;
+              } else if (item?.kind === "thoughtSignature" && item.thoughtSignature) {
+                standaloneThoughtSigs.push(item.thoughtSignature);
+              }
+            }
+          }
           for (const toolCall of msg.tool_calls) {
-            parts.push({
+            const callPart: any = {
               functionCall: {
                 name: toolCall.function.name,
                 // Google expects arguments as a parsed object, not a string
                 args: JSON.parse(toolCall.function.arguments || "{}"),
               },
-            });
+            };
+            if (sigByCallId[toolCall.id]) {
+              callPart.thoughtSignature = sigByCallId[toolCall.id];
+            }
+            parts.push(callPart);
             // Store the tool call to potentially link with a future tool response message
             assistantToolCalls[toolCall.id] = toolCall;
           }
+          // Re-attach any standalone thought-part signatures onto the leading
+          // text part(s) so reasoning-only thoughts are also round-tripped.
+          for (let s = 0; s < standaloneThoughtSigs.length; s++) {
+            const p: any = parts[s];
+            if (p && "text" in p && !p.thoughtSignature) {
+              p.thoughtSignature = standaloneThoughtSigs[s];
+            }
+          }
         }
 
         if (parts.length > 0) {
@@ -499,24 +526,51 @@ export class GenericGeminiClient implements GenericClient {
             return { message };
           }
 
+          // Capture Gemini thoughtSignatures so they can be round-tripped on the
+          // next turn. Gemini 3 REQUIRES these to be echoed back on the matching
+          // functionCall part or it returns a 400 "Thought signature is not
+          // valid" on the 2nd+ tool-calling turn. We key them by tool-call id
+          // (and also keep any standalone thought-part signatures in order).
+          const reasoningItems: any[] = [];
+
           candidate?.content?.parts?.forEach((part) => {
             if ("text" in part && typeof part.text === "string") {
               textContent += part.text; // Concatenate text parts
+              if ((part as any).thoughtSignature) {
+                reasoningItems.push({
+                  kind: "thoughtSignature",
+                  thoughtSignature: (part as any).thoughtSignature,
+                });
+              }
             } else if ("functionCall" in part && part.functionCall) {
+              const callId =
+                part.functionCall.id ||
+                `fc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
               message.tool_calls.push({
-                id:
-                  part.functionCall.id ||
-                  `fc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                id: callId,
                 type: "function",
                 function: {
                   name: part.functionCall.name,
                   arguments: JSON.stringify(part.functionCall.args || {}),
                 },
               });
+              if ((part as any).thoughtSignature) {
+                reasoningItems.push({
+                  kind: "functionCall",
+                  callId,
+                  thoughtSignature: (part as any).thoughtSignature,
+                });
+              }
             }
           });
 
           message.content = textContent || null;
+          if (reasoningItems.length > 0) {
+            (message as any)._reasoning_details = {
+              provider: "gemini",
+              items: reasoningItems,
+            };
+          }
 
           return { message };
         }) || []; // Handle case with no candidates