pi-commandcode-provider 0.5.1 → 0.6.1

package/src/auth-server.ts

@@ -28,6 +28,7 @@ export interface AuthServer {
 export interface AuthServerOptions {
   startPort?: number
   portRange?: number
+  expectedState?: string
 }
 
 function listenOnAvailablePort(
@@ -181,6 +182,12 @@ export async function startAuthServer(options: AuthServerOptions = {}): Promise<
           return
         }
 
+        if (options.expectedState !== undefined && state !== options.expectedState) {
+          res.writeHead(403)
+          res.end(JSON.stringify({ success: false, error: "Invalid state token" }))
+          return
+        }
+
         res.writeHead(200)
         res.end(JSON.stringify({ success: true }))
 

package/src/commandcode-catalog-overrides.ts

@@ -0,0 +1,23 @@
+import type { CommandCodeReasoningEffort } from "./commandcode-catalog.ts"
+
+/**
+ * Manual reasoning-effort policy for models the official CLI marks as
+ * reasoning-capable without publishing selectable efforts.
+ *
+ * `src/commandcode-catalog.ts` is generated from the CLI package and must stay
+ * byte-identical to upstream so the daily drift check works. Entries here are
+ * merged over the generated catalog at load time and are not touched by
+ * `npm run sync:commandcode-catalog`.
+ *
+ * Add a model only when the effort parameter is known to be accepted by the
+ * Command Code endpoint; remove it once the CLI catalog ships its own efforts.
+ */
+export const MODEL_EFFORT_OVERRIDES: Readonly<
+  Record<string, readonly CommandCodeReasoningEffort[]>
+> = {
+  // Meta Muse Spark: the CLI ships no effort levels, but the endpoint accepts
+  // `reasoning_effort` for these models and other hosts expose the same set.
+  "meta/muse-spark-1.1": ["minimal", "low", "medium", "high", "xhigh"],
+  "meta/muse-spark-1.2": ["minimal", "low", "medium", "high", "xhigh"],
+  "meta/muse-spark-1.2-contributor": ["minimal", "low", "medium", "high", "xhigh"],
+}

package/src/commandcode-catalog.ts

@@ -0,0 +1,152 @@
+export const COMMAND_CODE_CLI_VERSION = "1.40.1"
+
+export type CommandCodeInputType = "text" | "image"
+export type CommandCodeReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
+
+/**
+ * Generated from command-code@1.40.1 by `npm run sync:commandcode-catalog`.
+ * Do not edit manually.
+ */
+export const MODEL_INPUT_MODALITIES: Readonly<Record<string, readonly CommandCodeInputType[]>> = {
+  "claude-fable-5": ["text", "image"],
+  "claude-fable-5-1": ["text", "image"],
+  "claude-haiku-4-5-20251001": ["text", "image"],
+  "claude-opus-4-7": ["text", "image"],
+  "claude-opus-4-8": ["text", "image"],
+  "claude-opus-5": ["text", "image"],
+  "claude-sonnet-4-6": ["text", "image"],
+  "claude-sonnet-5": ["text", "image"],
+  "deepseek/deepseek-v4-flash-vision-exp": ["text", "image"],
+  "google/gemini-3.1-flash-lite": ["text", "image"],
+  "google/gemini-3.5-flash": ["text", "image"],
+  "google/gemini-3.5-flash-lite": ["text", "image"],
+  "google/gemini-3.6-flash": ["text", "image"],
+  "google/gemini-3.7-flash": ["text", "image"],
+  "gpt-5.3-codex": ["text", "image"],
+  "gpt-5.4": ["text", "image"],
+  "gpt-5.4-mini": ["text", "image"],
+  "gpt-5.5": ["text", "image"],
+  "gpt-5.6-luna": ["text", "image"],
+  "gpt-5.6-sol": ["text", "image"],
+  "gpt-5.6-terra": ["text", "image"],
+  "meta/muse-spark-1.1": ["text", "image"],
+  "meta/muse-spark-1.2": ["text", "image"],
+  "meta/muse-spark-1.2-contributor": ["text", "image"],
+  "MiniMaxAI/MiniMax-M3": ["text", "image"],
+  "moonshotai/Kimi-K2.5": ["text", "image"],
+  "moonshotai/Kimi-K2.6": ["text", "image"],
+  "moonshotai/Kimi-K2.7-Code": ["text", "image"],
+  "moonshotai/Kimi-K2.7-Code-Highspeed": ["text", "image"],
+  "moonshotai/Kimi-K3": ["text", "image"],
+  "Qwen/Qwen3.6-Plus": ["text", "image"],
+  "Qwen/Qwen3.7-Flash": ["text", "image"],
+  "Qwen/Qwen3.7-Plus": ["text", "image"],
+  "Qwen/Qwen3.8-27B": ["text", "image"],
+  "Qwen/Qwen3.8-Flash": ["text", "image"],
+  "Qwen/Qwen3.8-Max": ["text", "image"],
+  "sakana/fugu-ultra": ["text", "image"],
+  "stepfun/Step-3.7-Flash": ["text", "image"],
+  "thinkingmachines/inkling": ["text", "image"],
+  "thinkingmachines/inkling-small": ["text", "image"],
+  "xai/grok-4.5": ["text", "image"],
+  "xiaomi/mimo-v2.5": ["text", "image"],
+  "z-ai/glm-5.3-flash": ["text", "image"],
+}
+
+export const MODEL_REASONING: Readonly<Record<string, true>> = {
+  "claude-fable-5": true,
+  "claude-fable-5-1": true,
+  "claude-opus-4-7": true,
+  "claude-opus-4-8": true,
+  "claude-opus-5": true,
+  "claude-sonnet-4-6": true,
+  "claude-sonnet-5": true,
+  "deepseek/deepseek-v4-flash": true,
+  "deepseek/deepseek-v4-flash-fast": true,
+  "deepseek/deepseek-v4-flash-vision-exp": true,
+  "deepseek/deepseek-v4-pro": true,
+  "google/gemini-3.1-flash-lite": true,
+  "google/gemini-3.5-flash": true,
+  "google/gemini-3.5-flash-lite": true,
+  "google/gemini-3.6-flash": true,
+  "google/gemini-3.7-flash": true,
+  "gpt-5.3-codex": true,
+  "gpt-5.4": true,
+  "gpt-5.4-mini": true,
+  "gpt-5.5": true,
+  "gpt-5.6-luna": true,
+  "gpt-5.6-sol": true,
+  "gpt-5.6-terra": true,
+  "meta/muse-spark-1.1": true,
+  "meta/muse-spark-1.2": true,
+  "meta/muse-spark-1.2-contributor": true,
+  "MiniMaxAI/MiniMax-M3": true,
+  "moonshotai/Kimi-K2.7-Code": true,
+  "moonshotai/Kimi-K2.7-Code-Highspeed": true,
+  "moonshotai/Kimi-K3": true,
+  "nvidia/nemotron-3-ultra-550b-a55b": true,
+  "poolside/laguna-s-2.1-free": true,
+  "Qwen/Qwen3.6-Max-Preview": true,
+  "Qwen/Qwen3.6-Plus": true,
+  "Qwen/Qwen3.7-Flash": true,
+  "Qwen/Qwen3.7-Max": true,
+  "Qwen/Qwen3.7-Plus": true,
+  "Qwen/Qwen3.8-27B": true,
+  "Qwen/Qwen3.8-Flash": true,
+  "Qwen/Qwen3.8-Max": true,
+  "sakana/fugu-ultra": true,
+  "stepfun/Step-3.5-Flash": true,
+  "stepfun/Step-3.7-Flash": true,
+  "tencent/hy3-paid": true,
+  "tencent/hy4-preview": true,
+  "thinkingmachines/inkling": true,
+  "thinkingmachines/inkling-small": true,
+  "xai/grok-4.5": true,
+  "xai/grok-4.6": true,
+  "z-ai/glm-5.3-flash": true,
+  "zai-org/GLM-5.2": true,
+  "zai-org/GLM-5.3": true,
+}
+
+export const MODEL_EFFORTS: Readonly<Record<string, readonly CommandCodeReasoningEffort[]>> = {
+  "claude-fable-5": ["low", "medium", "high", "xhigh", "max"],
+  "claude-fable-5-1": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-7": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-8": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-5": ["low", "medium", "high", "xhigh", "max"],
+  "claude-sonnet-4-6": ["low", "medium", "high", "xhigh", "max"],
+  "claude-sonnet-5": ["low", "medium", "high", "xhigh", "max"],
+  "deepseek/deepseek-v4-flash": ["high", "max"],
+  "deepseek/deepseek-v4-flash-fast": ["low", "high", "max"],
+  "deepseek/deepseek-v4-flash-vision-exp": ["high", "max"],
+  "deepseek/deepseek-v4-pro": ["high", "max"],
+  "google/gemini-3.1-flash-lite": ["low", "medium", "high"],
+  "google/gemini-3.5-flash": ["low", "medium", "high"],
+  "google/gemini-3.5-flash-lite": ["low", "medium", "high"],
+  "google/gemini-3.6-flash": ["low", "medium", "high"],
+  "google/gemini-3.7-flash": ["low", "medium", "high"],
+  "gpt-5.3-codex": ["low", "medium", "high", "xhigh"],
+  "gpt-5.4": ["low", "medium", "high", "xhigh"],
+  "gpt-5.4-mini": ["low", "medium", "high"],
+  "gpt-5.5": ["low", "medium", "high", "xhigh"],
+  "gpt-5.6-luna": ["low", "medium", "high", "xhigh", "max"],
+  "gpt-5.6-sol": ["low", "medium", "high", "xhigh", "max"],
+  "gpt-5.6-terra": ["low", "medium", "high", "xhigh", "max"],
+  "moonshotai/Kimi-K3": ["low", "high", "max"],
+  "Qwen/Qwen3.8-27B": ["low", "medium", "xhigh"],
+  "Qwen/Qwen3.8-Flash": ["low", "medium", "xhigh"],
+  "Qwen/Qwen3.8-Max": ["low", "medium", "xhigh"],
+  "sakana/fugu-ultra": ["high", "xhigh"],
+  "tencent/hy4-preview": ["low", "medium", "high"],
+  "xai/grok-4.5": ["low", "medium", "high"],
+  "xai/grok-4.6": ["low", "medium", "high", "xhigh"],
+  "z-ai/glm-5.3-flash": ["low", "high", "max"],
+  "zai-org/GLM-5.2": ["high", "max"],
+  "zai-org/GLM-5.3": ["low", "high", "max"],
+}
+
+export const MODEL_MAX_OUTPUT_TOKENS: Readonly<Record<string, number>> = {
+  "poolside/laguna-s-2.1-free": 32_768,
+  "Qwen/Qwen3.8-27B": 32_768,
+  "z-ai/glm-5.3-flash": 131_072,
+}

package/src/converters.ts

@@ -66,9 +66,8 @@ function imageContentError(role: string): Error {
 
 export function assertTextOnlyMessages(messages?: readonly MessageLike[]): void {
   for (const message of messages ?? []) {
-    if (imageParts(message.content).length > 0) {
-      const role = message.role === "toolResult" ? "tool results" : `${message.role} messages`
-      throw imageContentError(role)
+    if (message.role !== "toolResult" && imageParts(message.content).length > 0) {
+      throw imageContentError(`${message.role} messages`)
     }
   }
 }
@@ -107,6 +106,7 @@ export function getApiKey(
   } = {},
 ): string | undefined {
   const env = options.env ?? process.env
+  if (env.COMMAND_CODE_API_KEY) return env.COMMAND_CODE_API_KEY
   if (env.COMMANDCODE_API_KEY) return env.COMMANDCODE_API_KEY
 
   const home = options.homeDir?.() ?? homedir()
@@ -138,7 +138,41 @@ export function getApiKey(
   return undefined
 }
 
+// Hosts such as OMP may pass a literal env-var name as the "resolved" registry
+// key instead of the actual credential. Treat those as unresolved.
+export const COMMAND_CODE_PLACEHOLDER_KEYS = new Set([
+  "$COMMAND_CODE_API_KEY",
+  "COMMAND_CODE_API_KEY",
+  "$COMMANDCODE_API_KEY",
+  "COMMANDCODE_API_KEY",
+])
+
+/**
+ * Pick the real API key from a host registry value and/or the env/auth-file
+ * fallback, never returning a literal placeholder or an empty/whitespace value.
+ * Pure/testable.
+ */
+export function pickCommandCodeApiKey(
+  registryKey: string | undefined,
+  hostKey: string | undefined,
+): string | undefined {
+  const trimmed = typeof registryKey === "string" ? registryKey.trim() : undefined
+  if (!trimmed) return hostKey
+  if (COMMAND_CODE_PLACEHOLDER_KEYS.has(trimmed)) return hostKey
+  return trimmed
+}
+
 export function textContent(message: { content?: unknown }): string {
+  if (typeof message.content === "string") return message.content
+  if (message.content === null || message.content === undefined) return ""
+  if (!Array.isArray(message.content)) {
+    try {
+      return JSON.stringify(message.content) ?? String(message.content)
+    } catch {
+      return String(message.content)
+    }
+  }
+
   return recordArray(message.content)
     .filter((part) => part.type === "text")
     .map((part) => stringValue(part.text) ?? "")
@@ -159,7 +193,12 @@ export function toolsToJson(tools?: readonly ToolLike[]): unknown[] {
   }))
 }
 
-function completeToolCallIds(messages?: readonly MessageLike[]): Set<string> {
+interface ToolCallState {
+  callIds: ReadonlySet<string>
+  resultIds: ReadonlySet<string>
+}
+
+function toolCallState(messages?: readonly MessageLike[]): ToolCallState {
   const callIds = new Set<string>()
   const resultIds = new Set<string>()
 
@@ -171,12 +210,12 @@ function completeToolCallIds(messages?: readonly MessageLike[]): Set<string> {
           if (id) callIds.add(id)
         }
       }
-    } else if (message.role === "toolResult") {
-      if (message.toolCallId) resultIds.add(message.toolCallId)
+    } else if (message.role === "toolResult" && message.toolCallId) {
+      resultIds.add(message.toolCallId)
     }
   }
 
-  return new Set([...callIds].filter((id) => resultIds.has(id)))
+  return { callIds, resultIds }
 }
 
 export function messagesToCC(
@@ -187,33 +226,57 @@ export function messagesToCC(
   if (!allowImages) assertTextOnlyMessages(messages)
 
   const out: unknown[] = []
-  const pairedToolCallIds = completeToolCallIds(messages)
+  const { callIds, resultIds } = toolCallState(messages)
 
   for (const message of messages ?? []) {
-    if (message.role === "user") {
+    if (message.role === "user" || message.role === "developer") {
+      // Hosts such as OMP steer the agent by injecting developer-role messages
+      // (advisor notes, reminders, nudges) mid-conversation. /alpha/generate
+      // only accepts user, assistant, and tool roles, so degrade the role to
+      // user instead of dropping the message. Content and chronological
+      // position are preserved; system-prompt hoisting would change semantics.
       out.push({
         role: "user",
         content: userContentToCommandCode(message.content, allowImages),
       })
     } else if (message.role === "assistant") {
       const parts: unknown[] = []
+      const missingResults: unknown[] = []
       for (const content of recordArray(message.content)) {
         if (content.type === "text") {
           parts.push({ type: "text", text: stringValue(content.text) ?? "" })
         } else if (content.type === "toolCall") {
           const toolCallId = stringValue(content.id) ?? ""
-          if (!pairedToolCallIds.has(toolCallId)) continue
+          const toolName = stringValue(content.name) ?? ""
+          if (!toolCallId) continue
           parts.push({
             type: "tool-call",
             toolCallId,
-            toolName: stringValue(content.name) ?? "",
+            toolName,
             input: recordOrEmpty(content.arguments),
           })
+          if (!resultIds.has(toolCallId)) {
+            missingResults.push({
+              type: "tool-result",
+              toolCallId,
+              toolName,
+              output: {
+                type: "error-text",
+                value: "No result — the tool call did not complete (interrupted or lost).",
+              },
+            })
+          }
         }
       }
       if (parts.length > 0) out.push({ role: "assistant", content: parts })
+      if (missingResults.length > 0) out.push({ role: "tool", content: missingResults })
     } else if (message.role === "toolResult") {
-      if (!message.toolCallId || !pairedToolCallIds.has(message.toolCallId)) continue
+      if (!message.toolCallId || !callIds.has(message.toolCallId)) continue
+      const images = imageParts(message.content)
+      const text = textContent(message)
+      const outputText =
+        text ||
+        (images.length > 0 && !allowImages ? "[Image omitted: model does not support images]" : "")
       out.push({
         role: "tool",
         content: [
@@ -222,15 +285,13 @@ export function messagesToCC(
             toolCallId: message.toolCallId,
             toolName: message.toolName,
             output: message.isError
-              ? { type: "error-text", value: textContent(message) }
-              : { type: "text", value: textContent(message) },
+              ? { type: "error-text", value: outputText }
+              : { type: "text", value: outputText },
           },
         ],
       })
 
-      const images = imageParts(message.content)
-      if (images.length > 0) {
-        if (!allowImages) throw imageContentError("tool results")
+      if (images.length > 0 && allowImages) {
         out.push({
           role: "user",
           content: images.map(imageToCommandCode),

package/src/core.ts

@@ -7,6 +7,7 @@
 
 import { randomUUID } from "node:crypto"
 
+import { COMMAND_CODE_CLI_VERSION } from "./commandcode-catalog.ts"
 import { commandCodeErrorMessage, redactCommandCodeErrorText } from "./overflow.ts"
 import { modelSupportsImageInput } from "./models.ts"
 import {
@@ -43,7 +44,7 @@ export * from "./overflow.ts"
 export * from "./types.ts"
 
 export const DEFAULT_API_BASE = "https://api.commandcode.ai"
-export const COMMAND_CODE_CLI_VERSION = "1.15.1"
+export { COMMAND_CODE_CLI_VERSION }
 
 const DEFAULT_GENERATE_MAX_TOKENS = 64_000
 const DEFAULT_MAX_RETRIES = 0
@@ -147,6 +148,10 @@ function mappedReasoningEffort(model: ModelLike, options?: StreamOptions): strin
   return typeof mapped === "string" && mapped !== "off" ? mapped : undefined
 }
 
+function isUuid(value: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)
+}
+
 export function projectSlugFromPath(pathName: string): string {
   const slug = pathName
     .toLowerCase()
@@ -231,17 +236,15 @@ export function createStreamCommandCode(deps: CoreDependencies) {
     const stream = deps.createStream()
 
     async function run() {
-      // OMP may pass the legacy env-var name "COMMANDCODE_API_KEY" (old pi)
-      // or "$COMMANDCODE_API_KEY" (new pi) as the apiKey value instead of
-      // resolving it. Filter out these specific strings.
-      const LEGACY_API_KEY_REF = "$COMMANDCODE_API_KEY"
-      const OLD_API_KEY_REF = "COMMANDCODE_API_KEY"
+      // Some hosts pass a literal env-var reference instead of resolving it.
+      const PLACEHOLDER_API_KEYS = new Set([
+        "$COMMAND_CODE_API_KEY",
+        "COMMAND_CODE_API_KEY",
+        "$COMMANDCODE_API_KEY",
+        "COMMANDCODE_API_KEY",
+      ])
       const hostKey =
-        options?.apiKey &&
-        options.apiKey !== LEGACY_API_KEY_REF &&
-        options.apiKey !== OLD_API_KEY_REF
-          ? options.apiKey
-          : undefined
+        options?.apiKey && !PLACEHOLDER_API_KEYS.has(options.apiKey) ? options.apiKey : undefined
 
       const apiKey =
         hostKey ??
@@ -261,7 +264,7 @@ export function createStreamCommandCode(deps: CoreDependencies) {
           usage: defaultUsage(),
           stopReason: "error",
           errorMessage:
-            "No Command Code API key. Run /login and select Command Code, set the COMMANDCODE_API_KEY env var, or configure ~/.commandcode/auth.json, ~/.pi/agent/auth.json or ~/.omp/agent/auth.json",
+            "No Command Code API key. Run /login and select Command Code, set COMMAND_CODE_API_KEY (or legacy COMMANDCODE_API_KEY), or configure ~/.commandcode/auth.json, ~/.pi/agent/auth.json or ~/.omp/agent/auth.json",
           timestamp: now(),
         }
         stream.push({ type: "error", reason: "error", error: msg })
@@ -285,6 +288,10 @@ export function createStreamCommandCode(deps: CoreDependencies) {
       let textBlock: TextContent | undefined
       let currentTextIdx = -1
       let thinkingIdx = -1
+      const streamingToolCalls = new Map<
+        string,
+        { contentIndex: number; toolCall: ToolCallContent; partialArgs: string }
+      >()
       let finished = false
 
       const abortUpstream = () => {
@@ -397,25 +404,81 @@ export function createStreamCommandCode(deps: CoreDependencies) {
             break
           }
 
-          case "tool-call": {
+          case "tool-input-start": {
             endTextBlock()
             endThinking()
+            const id = stringValue(event.id)
+            if (!id || streamingToolCalls.has(id)) break
+
             const toolCall: ToolCallContent = {
               type: "toolCall",
-              id: stringValue(event.toolCallId) ?? "",
+              id,
               name: stringValue(event.toolName) ?? "",
-              arguments: recordOrEmpty(event.input ?? event.args ?? event.arguments),
+              arguments: {},
             }
             output.content.push(toolCall)
-            const idx = output.content.length - 1
+            const contentIndex = output.content.length - 1
+            streamingToolCalls.set(id, { contentIndex, toolCall, partialArgs: "" })
             stream.push({
               type: "toolcall_start",
-              contentIndex: idx,
+              contentIndex,
               partial: output,
             })
+            break
+          }
+
+          case "tool-input-delta": {
+            const id = stringValue(event.id)
+            const delta = stringValue(event.delta)
+            if (!id || delta === undefined) break
+            const active = streamingToolCalls.get(id)
+            if (!active) break
+
+            active.partialArgs += delta
+            active.toolCall.arguments = recordOrEmpty(active.partialArgs)
+            stream.push({
+              type: "toolcall_delta",
+              contentIndex: active.contentIndex,
+              delta,
+              partial: output,
+            })
+            break
+          }
+
+          case "tool-input-end": {
+            break
+          }
+
+          case "tool-call": {
+            endTextBlock()
+            endThinking()
+            const id = stringValue(event.toolCallId) ?? ""
+            const active = streamingToolCalls.get(id)
+            const toolCall: ToolCallContent = active?.toolCall ?? {
+              type: "toolCall",
+              id,
+              name: stringValue(event.toolName) ?? "",
+              arguments: {},
+            }
+            toolCall.name = stringValue(event.toolName) ?? toolCall.name
+            toolCall.arguments = recordOrEmpty(event.input ?? event.args ?? event.arguments)
+
+            let contentIndex: number
+            if (active) {
+              contentIndex = active.contentIndex
+              streamingToolCalls.delete(id)
+            } else {
+              output.content.push(toolCall)
+              contentIndex = output.content.length - 1
+              stream.push({
+                type: "toolcall_start",
+                contentIndex,
+                partial: output,
+              })
+            }
             stream.push({
               type: "toolcall_end",
-              contentIndex: idx,
+              contentIndex,
               toolCall,
               partial: output,
             })
@@ -423,6 +486,15 @@ export function createStreamCommandCode(deps: CoreDependencies) {
           }
 
           case "finish": {
+            const rawFinishReason = stringValue(event.rawFinishReason)
+            if (
+              rawFinishReason &&
+              /^(?:network|connection|upstream)[-_\s]?error$/i.test(rawFinishReason)
+            ) {
+              throw new Error(
+                `Provider finished with reason "${rawFinishReason}" — upstream connection failed mid-stream`,
+              )
+            }
             const usage = commandCodeUsage(event)
             if (usage) {
               const details = commandCodeInputTokenDetails(usage)
@@ -446,6 +518,10 @@ export function createStreamCommandCode(deps: CoreDependencies) {
             break
           }
 
+          case "abort": {
+            throw abortError("Request aborted")
+          }
+
           case "error": {
             const message =
               commandCodeErrorMessage(event.error) ??
@@ -463,7 +539,11 @@ export function createStreamCommandCode(deps: CoreDependencies) {
         if (controller.signal.aborted) throw abortError("Aborted")
 
         const workingDir = cwd()
-        const threadId = uuid()
+        const threadId = options?.sessionId
+          ? isUuid(options.sessionId)
+            ? options.sessionId
+            : undefined
+          : uuid()
         const reasoningEffort = mappedReasoningEffort(model, options)
         const timeoutMs = options?.timeoutMs
 
@@ -491,8 +571,8 @@ export function createStreamCommandCode(deps: CoreDependencies) {
             tools: toolsToJson(context.tools),
             system: systemPromptToText(context.systemPrompt),
             max_tokens: generateMaxTokens(model, options),
-            temperature: 0.3,
             stream: true,
+            ...(options?.temperature !== undefined ? { temperature: options.temperature } : {}),
             ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
           },
           threadId,
@@ -522,7 +602,8 @@ export function createStreamCommandCode(deps: CoreDependencies) {
           "x-cli-environment": "production",
           "x-project-slug": projectSlugFromPath(workingDir),
           "x-taste-learning": "true",
-          "x-co-flag": "false",
+          ...(options?.sessionId ? { "x-session-id": options.sessionId } : {}),
+          "User-Agent": "cli",
           ...options?.headers,
         }
         const bodyStr = JSON.stringify(body)
@@ -635,6 +716,11 @@ export function createStreamCommandCode(deps: CoreDependencies) {
                 const { done, value } = await raceAbort(reader.read(), attemptController.signal)
                 if (done) {
                   if (buffer.trim()) handleEvent(parseStreamEventLine(buffer))
+                  if (!finished) {
+                    throw new Error(
+                      "Stream ended unexpectedly before completion (no finish event) — response was truncated",
+                    )
+                  }
                   break
                 }
                 if (controller.signal.aborted) throw abortError("Aborted")
@@ -658,7 +744,12 @@ export function createStreamCommandCode(deps: CoreDependencies) {
               } catch {}
               reader = undefined
 
-              if (controller.signal.aborted) throw streamError
+              if (
+                controller.signal.aborted ||
+                (streamError instanceof Error && streamError.name === "AbortError")
+              ) {
+                throw streamError
+              }
 
               // Never retry after visible content was emitted (including timeout mid-stream).
               const canRetry = output.content.length === 0 && attempt < maxRetries
@@ -695,7 +786,10 @@ export function createStreamCommandCode(deps: CoreDependencies) {
           }
         }
       } catch (error: unknown) {
-        const reason: ErrorReason = controller.signal.aborted ? "aborted" : "error"
+        const reason: ErrorReason =
+          controller.signal.aborted || (error instanceof Error && error.name === "AbortError")
+            ? "aborted"
+            : "error"
         output.stopReason = reason
         output.errorMessage =
           reason === "aborted"