@tyvm/knowhow 0.0.144 → 0.0.146

package/src/chat/modules/AgentModule.ts

@@ -18,7 +18,12 @@ import { BaseChatModule } from "./BaseChatModule";
 import { services } from "../../services/index";
 import { BaseAgent } from "../../agents/index";
 import { ChatCommand, ChatMode, ChatContext, ChatService } from "../types";
-import { Message, CompletionOptions } from "../../clients/types";
+import {
+  Message,
+  CompletionOptions,
+  REASONING_EFFORTS,
+  isReasoningEffort,
+} from "../../clients/types";
 import { ChatInteraction } from "../../types";
 import { Marked } from "../../utils/index";
 import { TokenCompressor } from "../../processors/TokenCompressor";
@@ -27,6 +32,7 @@ import {
   CustomVariables,
   XmlToolCallProcessor,
   HarmonyToolProcessor,
+  GemmaToolProcessor,
   Base64ImageProcessor,
   MinimalToolsMessageProcessor,
 } from "../../processors/index";
@@ -172,21 +178,15 @@ export class AgentModule extends BaseChatModule {
       {
         name: "reasoning_effort",
         description:
-          "Set the reasoning effort for the agent (none, low, medium, high). Use 'none' to disable thinking on models that support it.",
+          `Set the reasoning effort for the agent (${REASONING_EFFORTS.join(", ")}). Individual models support different subsets.`,
         handler: async (args: string[]): Promise<void> => {
-          const validEfforts: CompletionOptions["reasoning_effort"][] = [
-            "none",
-            "low",
-            "medium",
-            "high",
-          ];
-          const effort = args[0] as CompletionOptions["reasoning_effort"];
-          if (!effort || !validEfforts.includes(effort)) {
+          const effort = args[0];
+          if (!isReasoningEffort(effort)) {
             console.log(
               `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
             );
             console.log(
-              `Usage: /reasoning_effort <${validEfforts.join("|")}>`
+              `Usage: /reasoning_effort <${REASONING_EFFORTS.join("|")}>`
             );
             return;
           }
@@ -200,19 +200,13 @@ export class AgentModule extends BaseChatModule {
         name: "effort",
         description: "Alias for /reasoning_effort",
         handler: async (args: string[]): Promise<void> => {
-          const validEfforts: CompletionOptions["reasoning_effort"][] = [
-            "none",
-            "low",
-            "medium",
-            "high",
-          ];
-          const effort = args[0] as CompletionOptions["reasoning_effort"];
-          if (!effort || !validEfforts.includes(effort)) {
+          const effort = args[0];
+          if (!isReasoningEffort(effort)) {
             console.log(
               `Current reasoning effort: ${this.reasoningEffort ?? "(not set — model default)"}`
             );
             console.log(
-              `Usage: /effort <${validEfforts.join("|")}>`
+              `Usage: /effort <${REASONING_EFFORTS.join("|")}>`
             );
             return;
           }
@@ -246,8 +240,15 @@ export class AgentModule extends BaseChatModule {
         description: "Detach from the currently attached agent",
         modes: ["agent:attached"],
         handler: async (_args: string[]): Promise<void> => {
+          const agent = this.attachedAgent;
           console.log("Detached from agent");
-          this.detachFromAgent();
+          // Only detach if we are still attached to THIS agent. If the user
+          // killed this agent and started a new one while this agent was
+          // finishing a long tool call, detachFromAgent() would rip out the
+          // new agent's rendering and reset the mode.
+          if (agent && this.attachedAgent === agent) {
+            this.detachFromAgent();
+          }
         },
       },
       {
@@ -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
@@ -1345,8 +1468,15 @@ export class AgentModule extends BaseChatModule {
           }
 
           resolve("done");
-          // Exit agent:attached mode so the prompt resets back to the default
-          this.detachFromAgent();
+          // Exit agent:attached mode so the prompt resets back to the default.
+          // Only detach if we are still attached to THIS agent. If the user
+          // killed this agent and started a new one (or /attached to a different
+          // one) while this agent was finishing a long tool call, calling
+          // detachFromAgent() unconditionally would rip out the new agent's
+          // rendering listeners and reset the mode, making new output invisible.
+          if (this.attachedAgent === agent) {
+            this.detachFromAgent();
+          }
         });
       });
 

package/src/chat/modules/SessionsModule.ts

@@ -214,7 +214,6 @@ export class SessionsModule extends BaseChatModule {
     // ── Case 1: in-memory running task ──────────────────────────────────────
     if (taskRegistry.has(id)) {
       const taskInfo = taskRegistry.get(id)!;
-      const renderer = this.agentModule.getRenderer();
       const context = this.chatService?.getContext();
       const selectedAgent = taskInfo.agent;
 
@@ -222,13 +221,9 @@ export class SessionsModule extends BaseChatModule {
         context.selectedAgent = selectedAgent;
         context.agentMode = true;
         context.currentAgent = taskInfo.agentName;
-        context.activeAgentTaskId = id;
         context.currentModel = selectedAgent.getModel();
         context.currentProvider = selectedAgent.getProvider();
       }
-      this.agentModule.setActiveAgentTaskId(id);
-      renderer.setActiveTaskId(id);
-      if (this.chatService) this.chatService.setMode("agent:attached");
 
       console.log(`🔄 Attached to running task: ${id}`);
       console.log(`   Agent : ${taskInfo.agentName}`);
@@ -237,6 +232,13 @@ export class SessionsModule extends BaseChatModule {
       console.log(
         `   Type /logs to see recent messages, or /detach to detach.`
       );
+
+      // Route through attachedAgentChatLoop so that:
+      // 1. wireAgentRendering is called (new output becomes visible)
+      // 2. attachedAgent is set (so /poke, /kill, /compact work)
+      // 3. a done listener is registered (mode resets when agent finishes)
+      // Do NOT pass initialInput — agent is already running, no need to call it again.
+      await this.agentModule.attachedAgentChatLoop(id, selectedAgent as any);
       return;
     }
 
@@ -396,6 +398,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

@@ -3,6 +3,7 @@
  */
 import { ChatInteraction, Config } from "../types";
 import { BaseAgent } from "../agents/base/base";
+import { ReasoningEffort } from "../clients/types";
 import { ToolsService } from "../services";
 import { AgentRenderer } from "./renderer/types";
 
@@ -10,6 +11,9 @@ export interface ChatContext {
   debugMode?: boolean;
   agentMode?: boolean;
   currentAgent?: string;
+  defaultAgent?: string;
+  defaultModel?: string;
+  defaultProvider?: string;
   promptText?: string;
   searchMode?: boolean;
   voiceMode?: boolean;
@@ -94,6 +98,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?: ReasoningEffort;
+  summarizeReasoning?: boolean;
 }
 
 export interface ChatSession {
@@ -111,6 +121,11 @@ export interface ChatSession {
   threads: any[][];
   currentThread: number;
   lastUpdated: number;
+  // Persisted run configuration for exact resume restoration.
+  model?: string;
+  provider?: string;
+  reasoningEffort?: ReasoningEffort;
+  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

@@ -88,6 +88,25 @@ export class GenericAnthropicClient implements GenericClient {
     return undefined;
   }
 
+  /** Map provider-neutral effort names to Anthropic's output_config.effort. */
+  getEffortOutputConfig(
+    model: string,
+    reasoningEffort?: CompletionOptions["reasoning_effort"]
+  ): Anthropic.OutputConfig | undefined {
+    if (
+      reasoningEffort === undefined ||
+      reasoningEffort === "none" ||
+      (!alwaysOnModels.includes(model) && !optInModels.includes(model))
+    ) {
+      return undefined;
+    }
+
+    return {
+      // Anthropic uses `low` for the provider-neutral `minimal` level.
+      effort: reasoningEffort === "minimal" ? "low" : reasoningEffort,
+    };
+  }
+
   /**
    * Clean JSON Schema for Anthropic API compatibility.
    * Removes unsupported fields like additionalProperties, $ref, $defs, positional.
@@ -245,6 +264,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 +289,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,
@@ -406,6 +442,10 @@ export class GenericAnthropicClient implements GenericClient {
       options.reasoning_effort,
       options.reasoning_summary,
     );
+    const effortOutputConfig = this.getEffortOutputConfig(
+      options.model,
+      options.reasoning_effort
+    );
 
     const systemMessage = options.messages
       .filter((msg) => msg.role === "system")
@@ -430,6 +470,7 @@ export class GenericAnthropicClient implements GenericClient {
           : undefined,
         max_tokens: options.max_tokens || 8000,
         ...(thinkingParam && { thinking: thinkingParam }),
+        ...(effortOutputConfig && { output_config: effortOutputConfig }),
         ...(tools.length && {
           tool_choice: { type: "auto" },
           tools,
@@ -440,8 +481,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 +532,8 @@ export class GenericAnthropicClient implements GenericClient {
                     },
                   },
                 ],
+                ...(carryReasoning && reasoningDetails && { _reasoning_details: reasoningDetails }),
+                ...(carryReasoning && reasoningSummary && { reasoning_summary: reasoningSummary }),
               },
             };
           } else {
@@ -465,6 +542,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/fireworks.ts

@@ -51,6 +51,9 @@ export class GenericFireworksClient extends HttpClient {
       ...options,
       // Strip Anthropic-specific field not accepted by Fireworks
       long_ttl_cache: undefined,
+      // This is translated by the OpenAI/Anthropic clients, but is not part of
+      // Fireworks' OpenAI-compatible chat completion schema.
+      reasoning_summary: undefined,
     };
 
     if (sanitized.tools) {