flavor-code 1.3.11 → 1.3.12

package/dist/desktop/main.js

@@ -209,6 +209,13 @@ var ProviderConfigSchema = z2.object({
   cheapModel: z2.string().min(1).optional(),
   models: z2.array(z2.string().min(1)).max(100).optional(),
   maxOutputTokens: z2.number().int().positive().optional(),
+  // Extended-thinking budget in output tokens for the Anthropic protocol.
+  // Defaults to DEFAULT_THINKING_BUDGET; set to 0 to disable the request
+  // parameter. Provider thinking deltas are forwarded whenever they arrive.
+  thinkingBudget: z2.number().int().min(0).optional(),
+  // Reasoning effort requested from the OpenAI Responses protocol. Omitted by
+  // default so strict compatible gateways never see an unknown parameter.
+  thinkingEffort: z2.enum(["low", "medium", "high"]).optional(),
   // Send the Claude Code client fingerprint (User-Agent/x-app) with Anthropic requests,
   // for gateways that restrict the Anthropic protocol to Claude clients.
   claudeClient: z2.boolean().optional(),
@@ -5874,7 +5881,12 @@ function providerValidMessages(input) {
       const calls = original.toolCalls.filter((call) => call.id && call.name && availableResults.has(call.id));
       calls.forEach((call) => announced.add(call.id));
       if (!original.content && calls.length === 0) continue;
-      output.push({ role: "assistant", content: original.content, ...calls.length === 0 ? {} : { toolCalls: calls.map((call) => ({ ...call })) } });
+      output.push({
+        role: "assistant",
+        content: original.content,
+        ...calls.length === 0 ? {} : { toolCalls: calls.map((call) => ({ ...call })) },
+        ...original.thinkingBlocks === void 0 ? {} : { thinkingBlocks: original.thinkingBlocks.map((block) => ({ ...block })) }
+      });
       continue;
     }
     if (original.role === "tool") {
@@ -6597,6 +6609,7 @@ var AgentLoop = class {
       }
       let assistantText = "";
       const collectedToolCalls = [];
+      const collectedThinking = [];
       let completed = false;
       let reactiveRetried = false;
       let attempt = 1;
@@ -6634,6 +6647,7 @@ var AgentLoop = class {
         }
         assistantText = "";
         collectedToolCalls.length = 0;
+        collectedThinking.length = 0;
         completed = false;
         let terminalError;
         let providerError = false;
@@ -6654,6 +6668,10 @@ var AgentLoop = class {
               assistantText += event.text;
               accumulatedText += event.text;
               yield event;
+            } else if (event.type === "thinking") {
+              yield event;
+            } else if (event.type === "thinking-block") {
+              collectedThinking.push({ text: event.text, ...event.signature === void 0 ? {} : { signature: event.signature } });
             } else if (event.type === "tool-call") {
               collectedToolCalls.push({ kind: "valid", id: event.id, name: event.name, input: event.input });
             } else if (event.type === "invalid-tool-call") {
@@ -7001,7 +7019,8 @@ var AgentLoop = class {
       const assistantMessage = {
         role: "assistant",
         content: assistantText,
-        toolCalls: toolCalls.map(({ id, name, input }) => ({ id, name, input }))
+        toolCalls: toolCalls.map(({ id, name, input }) => ({ id, name, input })),
+        ...collectedThinking.length === 0 ? {} : { thinkingBlocks: collectedThinking.map((block) => ({ ...block })) }
       };
       this.#options.context.appendMany([assistantMessage, ...stagedMessages]);
       for (const { call, result } of stagedResults) {
@@ -13287,6 +13306,7 @@ var CLAUDE_CLIENT_HEADERS = {
   "x-app": "cli"
 };
 var DEFAULT_MAX_OUTPUT_TOKENS = 32768;
+var DEFAULT_THINKING_BUDGET = 8192;
 var MAX_CACHE_MARKERS = 4;
 function collectCacheMarkers(system, messages) {
   const markers = [];
@@ -13345,9 +13365,26 @@ function formatCacheUsage(model, snapshot4, shape) {
     ...shape === void 0 ? {} : { requestMessages: shape.messages, requestMarkers: shape.markers }
   });
 }
+function stripThinkingBlocks(messages) {
+  for (const message2 of messages) {
+    if (message2.role !== "assistant" || !Array.isArray(message2.content)) continue;
+    const blocks = message2.content;
+    if (!blocks.some((block) => block?.type === "thinking")) continue;
+    message2.content = blocks.filter((block) => block?.type !== "thinking");
+  }
+}
+function isThinkingParamRejected(error) {
+  const status = error?.status;
+  if (status !== void 0 && status !== 400) return false;
+  const message2 = error instanceof Error ? error.message : String(error ?? "");
+  return /\bthinking\b/iu.test(message2) && /(budget_tokens|expected|not supported|unsupported|unknown|invalid|extra inputs|unrecognized)/iu.test(message2);
+}
 var AnthropicModelAdapter = class {
   client;
   maxOutputTokens;
+  thinkingBudget;
+  /** Set once an endpoint rejects the `thinking` parameter; later requests stop sending it. */
+  #thinkingRejected = false;
   debugUsage;
   constructor(options) {
     const maxOutputTokens = options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
@@ -13355,6 +13392,7 @@ var AnthropicModelAdapter = class {
       throw new Error("maxOutputTokens must be a positive integer");
     }
     this.maxOutputTokens = maxOutputTokens;
+    this.thinkingBudget = options.thinkingBudget ?? DEFAULT_THINKING_BUDGET;
     this.debugUsage = options.debugUsage ?? isEnvTruthy(process.env.FLAVOR_DEBUG_USAGE);
     this.client = options.client ?? new Anthropic({
       ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
@@ -13362,6 +13400,16 @@ var AnthropicModelAdapter = class {
       ...options.headers === void 0 ? {} : { defaultHeaders: options.headers }
     });
   }
+  /**
+   * Extended-thinking request parameter when enabled, otherwise undefined.
+   * Anthropic requires the budget to fit inside max_tokens with a 1024 floor.
+   */
+  #thinkingParam() {
+    if (this.#thinkingRejected || this.thinkingBudget <= 0) return void 0;
+    const budget = Math.min(this.thinkingBudget, this.maxOutputTokens - 1);
+    if (budget < 1024) return void 0;
+    return { type: "enabled", budget_tokens: budget };
+  }
   #logUsage(request, snapshot4, shape) {
     const line = formatCacheUsage(request.model, snapshot4, shape);
     if (this.debugUsage) {
@@ -13417,7 +13465,13 @@ var AnthropicModelAdapter = class {
           }
           messages.push({ role: "user", content: results });
         } else if (message2.role === "assistant" && message2.toolCalls?.length) {
+          const echoThinking = this.#thinkingRejected ? [] : (message2.thinkingBlocks ?? []).filter((block) => block.signature !== void 0);
           const content = [
+            ...echoThinking.map((block) => ({
+              type: "thinking",
+              thinking: block.text,
+              signature: block.signature
+            })),
             ...modelContentText(message2.content) ? [{ type: "text", text: modelContentText(message2.content) }] : [],
             ...message2.toolCalls.map((call) => ({
               type: "tool_use",
@@ -13479,18 +13533,56 @@ var AnthropicModelAdapter = class {
         stream: true,
         messages,
         ...system ? { system } : {},
+        ...(() => {
+          const thinking = this.#thinkingParam();
+          return thinking === void 0 ? {} : { thinking };
+        })(),
         tools: [...request.tools].sort((a, b) => a.name.localeCompare(b.name)).map((tool) => ({
           name: tool.name,
           description: tool.description,
           input_schema: { ...tool.inputSchema, type: "object" }
         }))
       };
-      const stream = await this.client.messages.create(body, { signal: request.signal });
+      let stream;
+      try {
+        stream = await this.client.messages.create(body, { signal: request.signal });
+      } catch (error) {
+        if (this.thinkingBudget > 0 && !this.#thinkingRejected && isThinkingParamRejected(error)) {
+          this.#thinkingRejected = true;
+          delete body.thinking;
+          stripThinkingBlocks(body.messages);
+          stream = await this.client.messages.create(body, { signal: request.signal });
+        } else {
+          throw error;
+        }
+      }
+      const thinkingBuffers = /* @__PURE__ */ new Map();
       for await (const event of stream) {
         if (event.type === "message_start") {
           hasUsage = event.message?.usage !== void 0;
           inputTokens = updateInputUsage(inputUsage, event.message?.usage);
           outputTokens = event.message?.usage?.output_tokens ?? outputTokens;
+        } else if (event.type === "content_block_start" && event.content_block?.type === "thinking" && event.index !== void 0) {
+          thinkingBuffers.set(event.index, { text: "" });
+        } else if (event.type === "content_block_delta" && event.delta?.type === "thinking_delta") {
+          if (event.index !== void 0 && event.delta.thinking) {
+            const pending2 = thinkingBuffers.get(event.index);
+            if (pending2) pending2.text += event.delta.thinking;
+          }
+          if (event.delta.thinking) yield { type: "thinking", text: event.delta.thinking };
+        } else if (event.type === "content_block_delta" && event.delta?.type === "signature_delta" && event.index !== void 0) {
+          const pending2 = thinkingBuffers.get(event.index);
+          if (pending2) pending2.signature = (pending2.signature ?? "") + (event.delta.signature ?? "");
+        } else if (event.type === "content_block_stop" && event.index !== void 0 && thinkingBuffers.has(event.index)) {
+          const pending2 = thinkingBuffers.get(event.index);
+          if (pending2.text.length > 0 || pending2.signature !== void 0) {
+            yield {
+              type: "thinking-block",
+              text: pending2.text,
+              ...pending2.signature === void 0 ? {} : { signature: pending2.signature }
+            };
+          }
+          thinkingBuffers.delete(event.index);
         } else if (event.type === "content_block_start" && event.content_block?.type === "tool_use" && event.index !== void 0 && event.content_block.id && event.content_block.name) {
           pendingTools.set(event.index, {
             id: event.content_block.id,
@@ -13693,12 +13785,14 @@ function formatOpenAIUsage(model, breakdown) {
 var OpenAIModelAdapter = class {
   client;
   debugUsage;
+  thinkingEffort;
   constructor(options) {
     this.client = options.client ?? new OpenAI({
       ...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
       ...options.baseURL === void 0 ? {} : { baseURL: options.baseURL }
     });
     this.debugUsage = options.debugUsage ?? isEnvTruthy(process.env.FLAVOR_DEBUG_USAGE);
+    this.thinkingEffort = options.thinkingEffort;
   }
   #logUsage(model, breakdown) {
     if (breakdown === void 0) return;
@@ -13720,6 +13814,7 @@ var OpenAIModelAdapter = class {
       const body = {
         model: request.model,
         input: (await Promise.all(request.messages.map(toInput))).flat(),
+        ...this.thinkingEffort === void 0 ? {} : { reasoning: { effort: this.thinkingEffort } },
         tools: [...request.tools].sort((a, b) => a.name.localeCompare(b.name)).map((tool) => ({
           type: "function",
           name: tool.name,
@@ -13752,6 +13847,8 @@ var OpenAIModelAdapter = class {
           }
         } else if (event.type === "response.output_text.delta" && event.delta) {
           yield { type: "text", text: event.delta };
+        } else if ((event.type === "response.reasoning_summary_text.delta" || event.type === "response.reasoning_text.delta") && event.delta) {
+          yield { type: "thinking", text: event.delta };
         } else if (event.type === "response.function_call_arguments.done" && event.output_index !== void 0 && event.name) {
           const callId = callIds.get(event.output_index);
           if (callId && !emittedCalls.has(event.output_index)) {
@@ -15301,6 +15398,13 @@ import { basename as basename5, dirname as dirname15, join as join23, relative a
 import { randomUUID as randomUUID13 } from "crypto";
 import { z as z27 } from "zod";
 
+// src/ui/thinking-line.ts
+var THINKING_MAX_STORED_CHARS = 4e3;
+function appendThinkingText(previous, delta) {
+  const next = (previous ?? "") + delta;
+  return next.length > THINKING_MAX_STORED_CHARS ? next.slice(-THINKING_MAX_STORED_CHARS) : next;
+}
+
 // src/ui/transcript.ts
 function createTranscriptState() {
   return { completed: [], nextId: 1 };
@@ -15397,6 +15501,9 @@ function transcriptReducer(state, action) {
   if (event.type === "text") {
     return { ...state, active: addText(withoutModelActivity(state.active), event.text) };
   }
+  if (event.type === "thinking") {
+    return { ...state, active: attachThinking(state.active, event.text) };
+  }
   if (event.type === "tool-start") return upsertStatus({ ...state, active: withoutModelActivity(state.active) }, {
     kind: "status",
     id: `tool:${event.id}`,
@@ -15697,6 +15804,18 @@ function finishActive(state) {
     ...state.taskSnapshot === void 0 ? {} : { taskSnapshot: state.taskSnapshot }
   };
 }
+function attachThinking(turn, text) {
+  const blocks = [...turn.blocks];
+  const index = blocks.findIndex((block2) => block2.kind === "status" && block2.activity === "model" && block2.state === "running");
+  if (index < 0) return turn;
+  const block = blocks[index];
+  if (block === void 0 || block.kind !== "status") return turn;
+  blocks[index] = {
+    ...block,
+    thinkingText: appendThinkingText(block.thinkingText, text)
+  };
+  return { ...turn, blocks };
+}
 function withoutModelActivity(turn, id) {
   const blocks = turn.blocks.filter((block) => block.kind !== "status" || block.activity !== "model" || id !== void 0 && block.id !== id);
   if (blocks.length === turn.blocks.length) return turn;
@@ -26151,8 +26270,12 @@ ${renderMemoryDocument(entries)}`;
           };
           registry.register(next.providerId, next.apiType === "anthropic" ? new AnthropicModelAdapter({
             ...adapterOptions,
+            ...providerConfig?.thinkingBudget === void 0 ? {} : { thinkingBudget: providerConfig.thinkingBudget },
             ...providerConfig?.claudeClient === true ? { headers: CLAUDE_CLIENT_HEADERS } : {}
-          }) : new OpenAIModelAdapter(adapterOptions));
+          }) : new OpenAIModelAdapter({
+            ...adapterOptions,
+            ...providerConfig?.thinkingEffort === void 0 ? {} : { thinkingEffort: providerConfig.thinkingEffort }
+          }));
           effectiveLlm = next;
           mainModel = `${next.providerId}:${next.defaultModel}`;
           childModel = `${next.providerId}:${next.cheapModel}`;
@@ -26738,8 +26861,12 @@ async function registerConfiguredAdapters(providers, registry, environment, diag
       };
       const adapter = apiProtocol === "anthropic" ? new AnthropicModelAdapter({
         ...adapterOptions,
+        ...runtimeProvider.thinkingBudget === void 0 ? {} : { thinkingBudget: runtimeProvider.thinkingBudget },
         ...runtimeProvider.claudeClient === true ? { headers: CLAUDE_CLIENT_HEADERS } : {}
-      }) : new OpenAIModelAdapter(adapterOptions);
+      }) : new OpenAIModelAdapter({
+        ...adapterOptions,
+        ...runtimeProvider.thinkingEffort === void 0 ? {} : { thinkingEffort: runtimeProvider.thinkingEffort }
+      });
       const cacheProfile = resolveCacheProfile({ apiType: apiProtocol, baseURL: runtimeProvider.baseURL });
       if (apiProtocol === "openai" && isDashScopeBaseURL(runtimeProvider.baseURL)) {
         diagnostics.push(