@tyvm/knowhow 0.0.144 → 0.0.146

package/src/clients/pricing/fireworks.ts

@@ -1,4 +1,4 @@
-import { ModelPricing } from "./types";
+import { ModelPricing, ModelCatalogEntry, completions, embeddings } from "./types";
 
 /**
  * Fireworks AI model IDs, pricing, and catalog.
@@ -101,3 +101,52 @@ export const FireworksEmbeddingPricing: Record<string, ModelPricing> = {
   // Qwen3 Reranker 8B — $0.20/M tokens, context 40k
   [FireworksModels.Qwen3Reranker8b]: { input: 0.20, output: 0.20 },
 };
+
+
+// ─── Active text models (non-deprecated) ─────────────────────────────────────
+
+export const FireworksActiveTextModels: string[] = [
+  // Moonshot AI
+  FireworksModels.KimiK3,
+  FireworksModels.KimiK2p7Code,
+  FireworksModels.KimiK2_6,
+  FireworksModels.KimiK2_5,
+  // MiniMax
+  FireworksModels.MinimaxM3,
+  FireworksModels.MinimaxM2_7,
+  FireworksModels.MinimaxM2_5,
+  // Qwen
+  FireworksModels.Qwen3p7Plus,
+  // Z.ai
+  FireworksModels.Glm5p2,
+  FireworksModels.Glm5p1,
+  // DeepSeek AI
+  FireworksModels.DeepseekV4Pro,
+  FireworksModels.DeepseekV4Flash,
+  // OpenAI OSS
+  FireworksModels.GptOss120b,
+];
+
+export const FireworksDeprecatedTextModels: string[] = [
+  FireworksModels.Qwen3_6Plus,
+  FireworksModels.Qwen3p6Plus,
+  FireworksModels.Qwen3Vl30bA3bThinking,
+  FireworksModels.Qwen3Vl30bA3bInstruct,
+  FireworksModels.Qwen3_8b,
+  FireworksModels.Glm5,
+  FireworksModels.Glm4_7,
+  FireworksModels.DeepseekV3_2,
+  FireworksModels.DeepseekV3_1,
+];
+
+// ─── Catalog ──────────────────────────────────────────────────────────────────
+
+export const FIREWORKS_MODEL_CATALOG: ModelCatalogEntry[] = [
+  ...completions(FireworksActiveTextModels, "fireworks", FireworksTextPricing),
+  ...completions(FireworksDeprecatedTextModels, "fireworks", FireworksTextPricing),
+  ...embeddings(
+    [FireworksModels.Qwen3Embedding8b, FireworksModels.Qwen3Reranker8b],
+    "fireworks",
+    FireworksEmbeddingPricing,
+  ),
+];

package/src/clients/pricing/index.ts

@@ -35,7 +35,7 @@ export { GitHubModelsTextPricing } from "./github";
 export { OpenRouterTextPricing } from "./openrouter";
 export { LlamaTextPricing } from "./llama";
 export { CopilotTextPricing, CopilotModelMultipliers } from "./copilot";
-export { FireworksTextPricing } from "./fireworks";
+export { FireworksTextPricing, FireworksEmbeddingPricing, FIREWORKS_MODEL_CATALOG, FireworksActiveTextModels, FireworksDeprecatedTextModels } from "./fireworks";
 export { MetaTextPricing, MetaWebSearchPricingPer1000Queries } from "./meta";
 
 // ─── Combined catalog ─────────────────────────────────────────────────────────

package/src/clients/pricing/models.ts

@@ -7,17 +7,19 @@ import { OPENAI_MODEL_CATALOG } from "./openai";
 import { ANTHROPIC_MODEL_CATALOG } from "./anthropic";
 import { GOOGLE_MODEL_CATALOG } from "./google";
 import { XAI_MODEL_CATALOG } from "./xai";
+import { FIREWORKS_MODEL_CATALOG } from "./fireworks";
 
 export { ModelPricing, ModelType, ModelCatalogEntry };
 
 /** 2.5% platform markup applied on top of all provider base rates */
 export const USAGE_MARKUP_PERCENT = 2.5 / 100;
 
-export { OPENAI_MODEL_CATALOG, ANTHROPIC_MODEL_CATALOG, GOOGLE_MODEL_CATALOG, XAI_MODEL_CATALOG };
+export { OPENAI_MODEL_CATALOG, ANTHROPIC_MODEL_CATALOG, GOOGLE_MODEL_CATALOG, XAI_MODEL_CATALOG, FIREWORKS_MODEL_CATALOG };
 
 export const ALL_MODEL_CATALOG: ModelCatalogEntry[] = [
   ...OPENAI_MODEL_CATALOG,
   ...ANTHROPIC_MODEL_CATALOG,
   ...GOOGLE_MODEL_CATALOG,
   ...XAI_MODEL_CATALOG,
+  ...FIREWORKS_MODEL_CATALOG,
 ];

package/src/clients/pricing/openai.ts

@@ -232,8 +232,8 @@ export const OpenAiSearchModels: string[] = [
 export const OpenAiTextPricing: Record<string, ModelPricing> = {
   // gpt-5.6 series — short context / long context pricing
   [OpenAiModels.GPT_56_Sol]:   { input: 5.0, cached_input: 0.5,  cache_write: 6.25,  output: 30.0, input_gt_200k: 10.0, output_gt_200k: 45.0 },
-  [OpenAiModels.GPT_56_Terra]: { input: 2.5, cached_input: 0.25, cache_write: 3.125, output: 15.0, input_gt_200k: 5.0,  output_gt_200k: 22.5 },
-  [OpenAiModels.GPT_56_Luna]:  { input: 1.0, cached_input: 0.10, cache_write: 1.25,  output: 6.0,  input_gt_200k: 2.0,  output_gt_200k: 9.0  },
+  [OpenAiModels.GPT_56_Terra]: { input: 2.0, cached_input: 0.20, cache_write: 2.5,   output: 12.0, input_gt_200k: 4.0,  output_gt_200k: 18.0 },
+  [OpenAiModels.GPT_56_Luna]:  { input: 0.2, cached_input: 0.02, cache_write: 0.25,  output: 1.2,  input_gt_200k: 0.4,  output_gt_200k: 1.8  },
   [OpenAiModels.GPT_55]: { input: 5.0, cached_input: 0.5, output: 30.0 },
   [OpenAiModels.GPT_55_Pro]: { input: 30.0, cached_input: 0, output: 180.0, reasoningLevels: ["medium", "high", "xhigh"] },
   [OpenAiModels.GPT_54]: { input: 2.5, cached_input: 0.25, output: 15.0 },

package/src/clients/pricing/qwen.ts

@@ -0,0 +1,80 @@
+/**
+ * QWEN Cloud pricing (USD per 1M tokens)
+ * Source: https://home.qwencloud.com/data/api.json?product=AliyunDeliveryService&action=ListModelSeries
+ * International DashScope endpoint: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
+ * Last updated: 2026-08-03
+ *
+ * Notes:
+ * - Several Qwen models use tiered pricing based on input context length.
+ *   We use the standard tier (≤256k) as the base price here.
+ * - DeepSeek and GLM models are also available via QwenCloud's DashScope endpoint.
+ * - Video/image/audio generation models have per-second/per-image pricing (not per-token)
+ *   and are NOT included in QwenTextPricing.
+ */
+
+export const QwenTextPricing: Record<string, { input: number; output: number; cached_input?: number }> = {
+
+  // ---------------------------------------------------------------------------
+  // Qwen3.8 series (newest flagship, released 2026-08)
+  // ---------------------------------------------------------------------------
+  // qwen3.8-max: $2/$6, implicit cache: $0.25, explicit cache creation: $2.5, explicit cache read: $0.17
+  "qwen3.8-max": { input: 2.00, output: 6.00, cached_input: 0.25 },
+
+  // ---------------------------------------------------------------------------
+  // Qwen3.7 series
+  // ---------------------------------------------------------------------------
+  // qwen3.7-plus: tiered — ≤256k: $0.4/$1.6, 256k-1M: $1.2/$4.8
+  // implicit cache: $0.08 (≤256k), explicit cache creation: $0.5, explicit cache read: $0.04
+  "qwen3.7-plus": { input: 0.40, output: 1.60, cached_input: 0.08 },
+  "qwen3.7-plus-2026-05-26": { input: 0.40, output: 1.60, cached_input: 0.08 },
+
+  // qwen3.7-flash: tiered — ≤32k: $0.03/$0.13, 32k-256k: $0.10/$0.40, 256k-1M: $0.20/$0.80
+  "qwen3.7-flash": { input: 0.03, output: 0.13, cached_input: 0.006 },
+  "qwen3.7-flash-2026-07-15": { input: 0.03, output: 0.13, cached_input: 0.006 },
+
+  // qwen3.7-max: $2.50/$7.50, cache: $0.50
+  "qwen3.7-max": { input: 2.50, output: 7.50, cached_input: 0.50 },
+  "qwen3.7-max-2026-06-08": { input: 2.50, output: 7.50, cached_input: 0.50 },
+  "qwen3.7-max-2026-05-20": { input: 2.50, output: 7.50 },
+
+  // ---------------------------------------------------------------------------
+  // Qwen3.6 series
+  // ---------------------------------------------------------------------------
+  // qwen3.6-flash: tiered — ≤256k: $0.25/$1.50, 256k-1M: $1.00/$4.00
+  "qwen3.6-flash": { input: 0.25, output: 1.50, cached_input: 0.025 },
+  "qwen3.6-flash-2026-04-16": { input: 0.25, output: 1.50 },
+  // qwen3.6-plus: tiered — ≤256k: $0.50/$3.00, 256k-1M: $2.00/$6.00
+  "qwen3.6-plus": { input: 0.50, output: 3.00, cached_input: 0.05 },
+  "qwen3.6-plus-2026-04-02": { input: 0.50, output: 3.00 },
+
+  // ---------------------------------------------------------------------------
+  // Legacy alias models (qwen-turbo, qwen-plus, qwen-max, qwen-long)
+  // These are rolling aliases that point to the latest generation.
+  // ---------------------------------------------------------------------------
+  "qwen-turbo": { input: 0.05, output: 0.20, cached_input: 0.005 },
+  "qwen-turbo-latest": { input: 0.05, output: 0.20, cached_input: 0.005 },
+  "qwen-plus": { input: 0.40, output: 1.20, cached_input: 0.04 },
+  "qwen-plus-latest": { input: 0.40, output: 1.20, cached_input: 0.04 },
+  "qwen-max": { input: 0.861, output: 3.44, cached_input: 0.086 },
+  "qwen-max-latest": { input: 0.861, output: 3.44, cached_input: 0.086 },
+  // qwen-long: extended context up to 10M tokens
+  "qwen-long": { input: 0.05, output: 0.20, cached_input: 0.005 },
+
+  // ---------------------------------------------------------------------------
+  // DeepSeek models (available via QwenCloud/DashScope endpoint)
+  // ---------------------------------------------------------------------------
+  // DeepSeek-V4-Flash: lightweight MoE, 284B params, 13B activated, 1M context
+  "deepseek-v4-flash": { input: 0.20, output: 0.40, cached_input: 0.04 },
+  "deepseek-v4-flash-0731": { input: 0.20, output: 0.40, cached_input: 0.04 },
+  // DeepSeek-V4-Pro: flagship MoE, 1.6T params, 49B activated, 1M context
+  "deepseek-v4-pro": { input: 2.40, output: 4.80, cached_input: 0.20 },
+  // DeepSeek-V3.2: sparse attention, 128k context
+  // explicit cache creation: $0.713, explicit cache read: $0.057
+  "deepseek-v3.2": { input: 0.57, output: 1.71, cached_input: 0.114 },
+
+  // ---------------------------------------------------------------------------
+  // GLM models (Zhipu AI, available via QwenCloud/DashScope endpoint)
+  // ---------------------------------------------------------------------------
+  // GLM-5.2-Fast-Preview: 1M context, high-speed inference
+  "glm-5.2-fast-preview": { input: 2.80, output: 8.80, cached_input: 0.56 },
+};

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 {
@@ -88,6 +136,26 @@ export interface RetryOptions {
   signal?: AbortSignal;
 }
 
+/**
+ * Every reasoning-effort spelling currently exposed by a supported provider.
+ * Individual models may support only a subset; provider clients are responsible
+ * for translating or clamping values where their APIs require it.
+ */
+export const REASONING_EFFORTS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+] as const;
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
+
+export function isReasoningEffort(value: unknown): value is ReasoningEffort {
+  return typeof value === "string" && REASONING_EFFORTS.includes(value as ReasoningEffort);
+}
+
 export interface CompletionOptions extends RetryOptions {
   model: string;
   messages: Message[];
@@ -99,14 +167,17 @@ export interface CompletionOptions extends RetryOptions {
    * Maps to: OpenAI reasoning_effort/reasoning.effort, xAI reasoning.effort,
    *          Gemini thinkingLevel/thinkingBudget, Anthropic thinking mode.
    *
-   * "none"   = disable thinking entirely (Anthropic: thinking.type="disabled",
-   *            OpenAI: reasoning.effort="none").  Only supported by models that
-   *            allow disabling thinking (e.g. claude-sonnet-5).
-   * "low"    = minimal thinking
-   * "medium" = balanced (default for most models)
-   * "high"   = maximum reasoning
+   * "none"    = disable thinking where supported
+   * "minimal" = provider-defined minimum (for example Gemini/OpenAI)
+   * "low"     = low reasoning
+   * "medium"  = balanced reasoning
+   * "high"    = high reasoning
+   * "xhigh"   = extra-high reasoning (for example OpenAI/xAI/Anthropic)
+   * "max"     = maximum reasoning (Anthropic)
+   *
+   * A model may support only a subset of these provider-level values.
    */
-  reasoning_effort?: "none" | "low" | "medium" | "high";
+  reasoning_effort?: ReasoningEffort;
   /**
    * When true, request a summarized view of the model's thinking process.
    * - Anthropic: thinking.display = "summarized"
@@ -114,6 +185,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 +250,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

@@ -52,6 +52,15 @@ export class GenericXAIClient implements GenericClient {
     });
   }
 
+  resolveLegacyReasoningEffort(
+    effort: CompletionOptions["reasoning_effort"]
+  ): "low" | "medium" | "high" | undefined {
+    if (effort === undefined || effort === "none") return undefined;
+    if (effort === "minimal") return "low";
+    if (effort === "xhigh" || effort === "max") return "high";
+    return effort;
+  }
+
   async createChatCompletion(
     options: CompletionOptions
   ): Promise<CompletionResponse> {
@@ -72,13 +81,14 @@ export class GenericXAIClient implements GenericClient {
       return msg as ChatCompletionMessageParam;
     });
 
+    const reasoningEffort = this.resolveLegacyReasoningEffort(options.reasoning_effort);
     const response = await this.client.chat.completions.create({
       model: options.model,
       messages: xaiMessages,
       max_tokens: options.max_tokens,
-      ...(XaiReasoningModels.includes(options.model) && options.reasoning_effort && options.reasoning_effort !== "none" && {
+      ...(XaiReasoningModels.includes(options.model) && reasoningEffort && {
         // grok-3-mini models support reasoning_effort: "low" | "medium" | "high"
-        reasoning_effort: options.reasoning_effort as "low" | "medium" | "high",
+        reasoning_effort: reasoningEffort,
       }),
       ...(options.tools && {
         tools: options.tools,
@@ -116,6 +126,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 +157,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,
@@ -168,8 +216,17 @@ export class GenericXAIClient implements GenericClient {
     // Resolve reasoning effort, clamping to supported levels if defined in pricing
     const pricing = XaiTextPricing[options.model];
     const supportedLevels = pricing?.reasoningLevels;
-    let reasoningEffort: string | undefined = options.reasoning_effort;
-    if (supportedLevels?.length) {
+    const requestedEffort = options.reasoning_effort;
+    let reasoningEffort: string | undefined;
+    if (requestedEffort !== "none") {
+      reasoningEffort =
+        requestedEffort === "minimal"
+          ? "low"
+          : requestedEffort === "max"
+            ? "xhigh"
+            : requestedEffort;
+    }
+    if (requestedEffort !== "none" && supportedLevels?.length) {
       if (!reasoningEffort || !supportedLevels.includes(reasoningEffort)) {
         reasoningEffort = supportedLevels[0];
       }
@@ -182,7 +239,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 +286,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 +298,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 +328,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

@@ -8,6 +8,7 @@ import { SessionsModule } from "../chat/modules/SessionsModule";
 import { SetupModule } from "../chat/modules/SetupModule";
 import { PlainRenderer } from "../chat/renderer/PlainRenderer";
 import { loadRenderer } from "../chat/renderer/loadRenderer";
+import { isReasoningEffort, REASONING_EFFORTS } from "../clients/types";
 import { getConfig } from "../config";
 
 async function setupRenderer(chatService: any, rendererSpecifier: string): Promise<void> {
@@ -55,6 +56,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: ${REASONING_EFFORTS.join(", ")}. Individual models support different subsets.`
+    )
     .option(
       "--max-time-limit <minutes>",
       "Time limit for agent execution (minutes)",
@@ -99,6 +104,14 @@ export function addAgentCommand(program: Command, getChatService: () => any): vo
     )
     .action(async (options) => {
       try {
+        if (
+          options.reasoningEffort !== undefined &&
+          !isReasoningEffort(options.reasoningEffort)
+        ) {
+          throw new Error(
+            `Invalid reasoning effort "${options.reasoningEffort}". Expected one of: ${REASONING_EFFORTS.join(", ")}.`
+          );
+        }
         const { setupServices } = await import("./services");
         await setupServices();
         const chatService = getChatService();
@@ -116,17 +129,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 +233,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,