@mars-sea/dsh-commandcode-provider 0.10.0 → 0.10.1

package/lib/index.js

@@ -464,13 +464,21 @@ const KNOWN_EFFORTS = {
 		"low",
 		"medium",
 		"high",
-		"xhigh"
+		"xhigh",
+		"max"
 	],
 	"meta/muse-spark-1.3-contributor": [
 		"low",
 		"medium",
 		"high",
 		"xhigh"
+	],
+	"gpt-6-astra": [
+		"low",
+		"medium",
+		"high",
+		"xhigh",
+		"max"
 	]
 };
 /**
@@ -519,12 +527,12 @@ const KNOWN_IMAGE_MODELS = /* @__PURE__ */ new Set([
 	"gpt-5.6-luna",
 	"gpt-5.6-sol",
 	"gpt-5.6-terra",
+	"gpt-6-astra",
 	"meta/muse-spark-1.1",
 	"meta/muse-spark-1.2",
 	"meta/muse-spark-1.2-contributor",
 	"meta/muse-spark-1.3",
 	"meta/muse-spark-1.3-contributor",
-	"minimax/minimax-m3-free",
 	"moonshotai/Kimi-K2.5",
 	"moonshotai/Kimi-K2.6",
 	"moonshotai/Kimi-K2.7-Code",
@@ -540,7 +548,7 @@ const KNOWN_IMAGE_MODELS = /* @__PURE__ */ new Set([
 	"z-ai/glm-5.3-flash"
 ]);
 /**
-* Models the official CLI's model table (command-code@1.46.0) marks
+* Models the official CLI's model table (command-code@1.50.0) marks
 * `reasoning:!0` but defines no selectable `reasoning_effort` levels — they
 * think automatically, with Command Code driving the depth. This is the
 * authoritative "thinks, effort not adjustable" set: `KNOWN_EFFORTS` (which
@@ -548,7 +556,7 @@ const KNOWN_IMAGE_MODELS = /* @__PURE__ */ new Set([
 * effort levels, and this snapshot is not surfaced in the picker's compact
 * description — it exists for programmatic consumers.
 *
-* Source: the command-code@1.46.0 bundled model table (dist/cli.mjs),
+* Source: the command-code@1.50.0 bundled model table (dist/cli.mjs),
 * cross-checked with https://commandcode.ai/docs/reference/cli/models.
 * (`stealth/ox-alpha` left this set in command-code@1.32.1, which gave it
 * selectable `['low', 'high', 'max']` efforts; the preview then ended in
@@ -571,7 +579,6 @@ const KNOWN_THINKING_MODELS = /* @__PURE__ */ new Set([
 	"Qwen/Qwen3.7-Flash",
 	"Qwen/Qwen3.7-Max",
 	"Qwen/Qwen3.7-Plus",
-	"minimax/minimax-m3-free",
 	"moonshotai/Kimi-K2.7-Code",
 	"moonshotai/Kimi-K2.7-Code-Highspeed",
 	"stepfun/Step-3.5-Flash",
@@ -624,12 +631,9 @@ const KNOWN_PLANS = {
 	"deepseek/deepseek-v4-flash-vision-exp": "go",
 	"deepseek/deepseek-v4-pro": "go",
 	"gpt-5.6-luna": "go",
-	"inclusionai/ling-3.0-flash-free": "go",
 	"meituan/LongCat-2.0:free": "go",
 	"meta/muse-spark-1.2-contributor": "go",
 	"meta/muse-spark-1.3-contributor": "go",
-	"minimax/minimax-m2.7-free": "go",
-	"minimax/minimax-m3-free": "go",
 	"moonshotai/Kimi-K2.5": "go",
 	"moonshotai/Kimi-K2.6": "go",
 	"moonshotai/Kimi-K2.7-Code": "go",
@@ -639,7 +643,6 @@ const KNOWN_PLANS = {
 	"poolside/laguna-s-2.1-free": "go",
 	"stepfun/Step-3.5-Flash": "go",
 	"stepfun/Step-3.7-Flash": "go",
-	"tencent/Hy3": "go",
 	"tencent/hy3-paid": "go",
 	"tencent/hy4-preview": "go",
 	"thinkingmachines/inkling": "go",
@@ -677,6 +680,7 @@ const KNOWN_PLANS = {
 	"claude-opus-4-7": "provider",
 	"claude-opus-4-8": "provider",
 	"claude-opus-5": "provider",
+	"gpt-6-astra": "provider",
 	"sakana/fugu-ultra": "provider"
 };
 /** Official display labels for each plan tier. */
@@ -724,8 +728,8 @@ function compareByPlan(a, b) {
 }
 /**
 * Subscription plan table, synced from the official CLI bundle's plan maps
-* (`Nn`/`$n` in command-code@1.31.0 `dist/cli.mjs`, re-verified unchanged
-* against 1.32.2 where they appear as `Zn`/`er`): subscription `planId`
+* (located by the `"individual-go"` key in command-code@1.50.0 `dist/cli.mjs`,
+* re-verified unchanged through 1.50.0): subscription `planId`
 * prefix → display name and the plan's monthly credit total. This is the
 * account's own subscription (from `/alpha/billing/subscriptions`) — distinct
 * from {@link KNOWN_PLANS}, which maps catalog models to their minimum tier.
@@ -935,7 +939,7 @@ function capabilityDescription(modelId, contextWindow, now = Date.now()) {
 * and API key or subscription, and Command Code's terms apply.
 *
 * Wire protocol (reverse-engineered by the pi plugin, command-code@1.28.4;
-* re-verified against command-code@1.44.0 — endpoints, request shape, and
+* re-verified against command-code@1.50.0 — endpoints, request shape, and
 * stream events unchanged):
 *   POST {apiBase}/alpha/generate
 *   body: { config, memory, taste, skills, params: { model, messages, tools,
@@ -948,7 +952,7 @@ function capabilityDescription(modelId, contextWindow, now = Date.now()) {
 * per-request options thunk and an API-key resolver from the plugin entry
 * (src/index.ts), so a settings change reaches the very next request.
 */
-const COMMAND_CODE_CLI_VERSION = "1.47.0";
+const COMMAND_CODE_CLI_VERSION = "1.50.0";
 const DEFAULT_API_BASE = "https://api.commandcode.ai";
 const DEFAULT_GENERATE_MAX_TOKENS = 64e3;
 const DEFAULT_MAX_OUTPUT_TOKENS = 65536;
@@ -1109,6 +1113,40 @@ function pairedToolCalls(messages) {
 		names
 	};
 }
+/**
+* The Command Code gateway rejects tool call ids longer than 64 characters
+* (`input[N].call_id` must be `<= 64`, issue #23). Cross-provider histories
+* can carry longer ids — e.g. switching to Command Code mid-session after
+* another provider issued the call — so overlong paired ids are remapped to
+* short per-request aliases. Correlation only needs to hold within one
+* request (each call travels with its result in the same body), so a
+* sequential alias is enough: no durable state, no cross-request stability,
+* and the harness log keeps the original ids.
+*/
+const MAX_WIRE_TOOL_CALL_ID_LENGTH = 64;
+/**
+* Map each paired tool-call id to its wire id: ids within the gateway limit
+* pass through verbatim, overlong ids get a collision-free `cc-<n>` alias.
+* Callers must resolve BOTH the tool-call and its paired tool-result through
+* the returned map so the pair stays correlated.
+*/
+function wireToolCallIds(paired) {
+	const wire = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	for (const id of paired) if (id.length <= MAX_WIRE_TOOL_CALL_ID_LENGTH) {
+		wire.set(id, id);
+		taken.add(id);
+	}
+	let seq = 1;
+	for (const id of paired) {
+		if (wire.has(id)) continue;
+		let alias = `cc-${seq++}`;
+		while (taken.has(alias)) alias = `cc-${seq++}`;
+		wire.set(id, alias);
+		taken.add(alias);
+	}
+	return wire;
+}
 function blockText(block) {
 	return block.type === "text" || block.type === "reasoning" ? block.text : "";
 }
@@ -1139,6 +1177,7 @@ async function imageToCommandCode(ref, readImage) {
 async function messagesToCC(messages, readImage) {
 	const out = [];
 	const { ids: paired, names: toolNames } = pairedToolCalls(messages);
+	const wireIds = wireToolCallIds(paired);
 	for (const message of messages) {
 		if (message.role === "system") continue;
 		if (message.role === "user" && message.source.kind !== "tool") {
@@ -1167,7 +1206,7 @@ async function messagesToCC(messages, readImage) {
 			});
 			else if (block.type === "tool-call" && paired.has(block.id)) parts.push({
 				type: "tool-call",
-				toolCallId: block.id,
+				toolCallId: wireIds.get(block.id) ?? block.id,
 				toolName: block.name,
 				input: recordOrEmpty(block.arguments)
 			});
@@ -1184,7 +1223,7 @@ async function messagesToCC(messages, readImage) {
 				role: "tool",
 				content: [{
 					type: "tool-result",
-					toolCallId: block.toolCallId,
+					toolCallId: wireIds.get(block.toolCallId) ?? block.toolCallId,
 					toolName: toolNames.get(block.toolCallId) || "unknown",
 					output: block.isError ? {
 						type: "error-text",
@@ -1199,6 +1238,89 @@ async function messagesToCC(messages, readImage) {
 	}
 	return out;
 }
+/**
+* Convert one image reference to the OpenAI Chat Completions wire format:
+* `{ type: 'image_url', image_url: { url: 'data:...;base64,...' } }`.
+*/
+async function imageToOpenAI(ref, readImage) {
+	const data = await readImage(ref);
+	return {
+		type: "image_url",
+		image_url: { url: `data:${ref.mediaType};base64,${Buffer.from(data).toString("base64")}` }
+	};
+}
+/**
+* Convert harness messages to the OpenAI Chat Completions request shape.
+*
+* Unlike the Command Code CLI transport, this transport is the documented
+* Provider API surface. DeepSeek's thinking-mode contract requires historical
+* `reasoning_content` to be passed back whenever tools are in play, so this
+* converter intentionally DOES replay reasoning blocks as `reasoning_content`
+* on assistant messages. Only tool calls with a paired tool result are
+* replayed (same policy as the CLI path).
+*/
+async function messagesToOpenAI(messages, readImage) {
+	const out = [];
+	const { ids: paired } = pairedToolCalls(messages);
+	const wireIds = wireToolCallIds(paired);
+	for (const message of messages) {
+		if (message.role === "system") continue;
+		if (message.role === "user" && message.source.kind !== "tool") {
+			const parts = [];
+			for (const block of message.content) {
+				if (block.type === "text") parts.push({
+					type: "text",
+					text: block.text
+				});
+				if (block.type === "image") {
+					if (!readImage) throw new LlmError("Image input requires the durable attachment service", "UNSUPPORTED_CONTENT");
+					parts.push(await imageToOpenAI(block.attachment, readImage));
+				}
+			}
+			if (parts.length === 0) continue;
+			if (!parts.some((part) => part.type === "image_url") && parts.length === 1) out.push({
+				role: "user",
+				content: parts[0].text
+			});
+			else out.push({
+				role: "user",
+				content: parts
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+			const reasoning = message.content.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+			const toolCalls = message.content.filter((block) => block.type === "tool-call" && paired.has(block.id)).map((block) => ({
+				id: wireIds.get(block.id) ?? block.id,
+				type: "function",
+				function: {
+					name: block.name,
+					arguments: block.arguments
+				}
+			}));
+			if (text === "" && reasoning === "" && toolCalls.length === 0) continue;
+			const assistant = {
+				role: "assistant",
+				content: text === "" ? null : text
+			};
+			if (reasoning !== "") assistant.reasoning_content = reasoning;
+			if (toolCalls.length > 0) assistant.tool_calls = toolCalls;
+			out.push(assistant);
+			continue;
+		}
+		if (message.role === "user" && message.source.kind === "tool") {
+			const block = message.content[0];
+			if (!block || block.type !== "tool-result" || !paired.has(block.toolCallId)) continue;
+			out.push({
+				role: "tool",
+				tool_call_id: wireIds.get(block.toolCallId) ?? block.toolCallId,
+				content: toolResultText(block)
+			});
+		}
+	}
+	return out;
+}
 /** Account endpoints fetched by one `getUsage()` run (see the classification there). */
 const USAGE_ENDPOINT_COUNT = 4;
 var CommandCodeAdapter = class extends LlmAdapter {
@@ -1208,6 +1330,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 	resolveAttachments;
 	billingAccess = /* @__PURE__ */ new Map();
 	billingAccessInflight = /* @__PURE__ */ new Map();
+	protocolCache = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		super();
 		this.deps = deps;
@@ -1397,6 +1520,41 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			return;
 		}
 	}
+	/** Fresh cached billing tier weight for a key, or undefined when not known. */
+	cachedBillingTierWeight(apiKey) {
+		const hit = this.billingAccess.get(apiKey);
+		if (hit === void 0 || Date.now() - hit.at >= 3e5) return void 0;
+		return hit.value?.tierWeight;
+	}
+	/** Cached protocol decision for a key, or undefined when expired/unknown. */
+	cachedProtocolUseCli(apiKey) {
+		const hit = this.protocolCache.get(apiKey);
+		if (hit === void 0 || Date.now() - hit.at >= 9e5) return void 0;
+		return hit.useCli;
+	}
+	rememberProtocol(apiKey, useCli) {
+		this.protocolCache.set(apiKey, {
+			useCli,
+			at: Date.now()
+		});
+	}
+	/**
+	* Choose the initial protocol for one request. A fresh protocol cache entry
+	* wins; otherwise a cached (not network-fetched) billing tier of Go is
+	* treated as CLI-only. Unknown accounts default to Provider API and fall
+	* back only after an `upgrade_required` rejection.
+	*/
+	resolveProtocol(apiKey) {
+		const forced = this.deps.options().protocol;
+		if (forced === "cli" || forced === "openai") return forced;
+		const cached = this.cachedProtocolUseCli(apiKey);
+		if (cached !== void 0) return cached ? "cli" : "openai";
+		if (this.cachedBillingTierWeight(apiKey) === 0) {
+			this.rememberProtocol(apiKey, true);
+			return "cli";
+		}
+		return "openai";
+	}
 	/**
 	* Fetch account, usage, credit, and subscription state from the Command
 	* Code account endpoints (`/alpha/whoami`, `/alpha/usage/summary`,
@@ -1543,44 +1701,70 @@ var CommandCodeAdapter = class extends LlmAdapter {
 		const supported = KNOWN_EFFORTS[options.model];
 		const reasoningEffort = effort && effort !== "off" && supported?.includes(effort) ? effort : void 0;
 		const systemText = [options.system ?? "", ...options.messages.filter((m) => m.role === "system").map((m) => m.content.map(blockText).filter(Boolean).join("\n"))].filter(Boolean).join("\n\n");
-		const body = {
-			config: {
-				workingDir: connection.workingDir,
-				date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-				environment: `${process.platform}-${process.arch}, Node.js ${process.version}`,
-				structure: [],
-				isGitRepo: false,
-				currentBranch: "",
-				mainBranch: "",
-				gitStatus: "",
-				recentCommits: []
-			},
-			memory: null,
-			taste: null,
-			skills: null,
-			params: {
-				model: options.model,
-				messages: await messagesToCC(options.messages, readImage),
-				tools: (options.tools ?? []).map((tool) => ({
-					type: "function",
+		let protocol = this.resolveProtocol(apiKey);
+		const buildBody = async (target) => {
+			if (target === "cli") return {
+				config: {
+					workingDir: connection.workingDir,
+					date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+					environment: `${process.platform}-${process.arch}, Node.js ${process.version}`,
+					structure: [],
+					isGitRepo: false,
+					currentBranch: "",
+					mainBranch: "",
+					gitStatus: "",
+					recentCommits: []
+				},
+				memory: null,
+				taste: null,
+				skills: null,
+				params: {
+					model: options.model,
+					messages: await messagesToCC(options.messages, readImage),
+					tools: (options.tools ?? []).map((tool) => ({
+						type: "function",
+						name: tool.name,
+						description: tool.description,
+						input_schema: tool.parameters
+					})),
+					system: systemText,
+					max_tokens: maxTokens,
+					temperature: options.temperature ?? .3,
+					stream: true,
+					...reasoningEffort ? { reasoning_effort: reasoningEffort } : {}
+				},
+				threadId: randomUUID()
+			};
+			const openAiMessages = [...systemText ? [{
+				role: "system",
+				content: systemText
+			}] : [], ...await messagesToOpenAI(options.messages, readImage)];
+			const openAiTools = (options.tools ?? []).map((tool) => ({
+				type: "function",
+				function: {
 					name: tool.name,
 					description: tool.description,
-					input_schema: tool.parameters
-				})),
-				system: systemText,
+					parameters: tool.parameters
+				}
+			}));
+			return {
+				model: options.model,
+				messages: openAiMessages,
+				...openAiTools.length > 0 ? { tools: openAiTools } : {},
 				max_tokens: maxTokens,
 				temperature: options.temperature ?? .3,
 				stream: true,
 				...reasoningEffort ? { reasoning_effort: reasoningEffort } : {}
-			},
-			threadId: randomUUID()
+			};
 		};
+		let body = await buildBody(protocol);
 		const connect = async (key) => {
 			const connectAbort = new AbortController();
 			let connectTimedOut = false;
+			const endpoint = protocol === "cli" ? `${connection.apiBase}/alpha/generate` : `${connection.apiBase}/provider/v1/chat/completions`;
 			const connectTimer = setTimeout(() => {
 				connectTimedOut = true;
-				connectAbort.abort(new DOMException(`Command Code API request to ${connection.apiBase}/alpha/generate did not respond within ${connection.requestTimeoutMs}ms`, "TimeoutError"));
+				connectAbort.abort(new DOMException(`Command Code API request to ${endpoint} did not respond within ${connection.requestTimeoutMs}ms`, "TimeoutError"));
 			}, connection.requestTimeoutMs);
 			const onCallerAbort = () => {
 				connectAbort.abort(options.signal?.reason);
@@ -1594,19 +1778,25 @@ var CommandCodeAdapter = class extends LlmAdapter {
 				if (options.signal) options.signal.removeEventListener("abort", onCallerAbort);
 			};
 			let response;
+			const headers = protocol === "cli" ? {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${key}`,
+				"x-command-code-version": COMMAND_CODE_CLI_VERSION,
+				"x-cli-environment": "production",
+				"x-project-slug": projectSlugFromPath(connection.workingDir),
+				"x-taste-learning": "true",
+				"x-co-flag": "false",
+				...attributionHeaders()
+			} : {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${key}`,
+				Accept: "text/event-stream",
+				...attributionHeaders()
+			};
 			try {
-				response = await this.fetchImpl(`${connection.apiBase}/alpha/generate`, {
+				response = await this.fetchImpl(endpoint, {
 					method: "POST",
-					headers: {
-						"Content-Type": "application/json",
-						Authorization: `Bearer ${key}`,
-						"x-command-code-version": COMMAND_CODE_CLI_VERSION,
-						"x-cli-environment": "production",
-						"x-project-slug": projectSlugFromPath(connection.workingDir),
-						"x-taste-learning": "true",
-						"x-co-flag": "false",
-						...attributionHeaders()
-					},
+					headers,
 					body: JSON.stringify(body),
 					signal: connectAbort.signal
 				});
@@ -1614,8 +1804,8 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			} catch (error) {
 				cleanup();
 				if (options.signal?.aborted) throw error;
-				if (connectTimedOut || error instanceof DOMException && error.name === "TimeoutError") throw new LlmError(`Command Code API request to ${connection.apiBase}/alpha/generate did not respond within ${connection.requestTimeoutMs}ms: ${errorChain(error)}；Command Code API 请求在 ${connection.requestTimeoutMs} 毫秒内未收到响应——通常是网络或代理问题，请检查后重试`, "TIMEOUT", { cause: error });
-				throw new LlmError(`Command Code API request to ${connection.apiBase}/alpha/generate failed: ${errorChain(error)}；Command Code API 请求连接失败——通常是网络或代理问题，请检查网络或代理设置后重试`, "TRANSPORT", { cause: error });
+				if (connectTimedOut || error instanceof DOMException && error.name === "TimeoutError") throw new LlmError(`Command Code API request to ${endpoint} did not respond within ${connection.requestTimeoutMs}ms: ${errorChain(error)}；Command Code API 请求在 ${connection.requestTimeoutMs} 毫秒内未收到响应——通常是网络或代理问题，请检查后重试`, "TIMEOUT", { cause: error });
+				throw new LlmError(`Command Code API request to ${endpoint} failed: ${errorChain(error)}；Command Code API 请求连接失败——通常是网络或代理问题，请检查网络或代理设置后重试`, "TRANSPORT", { cause: error });
 			}
 			if (!response.ok) {
 				const errText = await response.text().catch(() => "");
@@ -1644,6 +1834,12 @@ var CommandCodeAdapter = class extends LlmAdapter {
 				connected = attempt;
 				break;
 			}
+			if (protocol === "openai" && isUpgradeRequiredError(attempt.status, attempt.errText)) {
+				protocol = "cli";
+				this.rememberProtocol(apiKey, true);
+				body = await buildBody("cli");
+				continue;
+			}
 			const rotate = this.deps.rotateApiKey;
 			if ((attempt.status === 429 || attempt.status === 401) && rotate !== void 0 && options.signal?.aborted !== true && tried.size < MAX_ACCOUNT_ROTATIONS) {
 				const next = await rotate(apiKey, attempt.status === 429 ? "rate-limit" : "invalid-credential", connection, options.model);
@@ -1709,7 +1905,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			reasoningIndex = -1;
 			reasoningContent = "";
 		};
-		const handleEvent = (event) => {
+		const handleCliEvent = (event) => {
 			const chunks = [];
 			if (!isRecord(event)) return chunks;
 			switch (event.type) {
@@ -1825,6 +2021,128 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			}
 			return chunks;
 		};
+		const openAiToolCalls = [];
+		const emitOpenAiToolCalls = function* () {
+			for (const call of openAiToolCalls) {
+				const id = call.id ?? randomUUID();
+				const name = call.name ?? "";
+				const args = call.arguments || "{}";
+				const index = nextIndex++;
+				sawContent = true;
+				yield {
+					type: "block-start",
+					index,
+					blockType: "tool-call"
+				};
+				yield {
+					type: "tool-call-delta",
+					index,
+					id: ToolCallId(id),
+					name,
+					argumentsDelta: args
+				};
+				yield {
+					type: "block-end",
+					index,
+					block: {
+						type: "tool-call",
+						id: ToolCallId(id),
+						name,
+						arguments: args
+					}
+				};
+			}
+			openAiToolCalls.length = 0;
+		};
+		const handleOpenAIEvent = (event) => {
+			const chunks = [];
+			if (!isRecord(event)) return chunks;
+			const choices = event.choices;
+			if (!Array.isArray(choices) || choices.length === 0) {
+				if (event.usage !== void 0) chunks.push({
+					type: "usage",
+					usage: mapOpenAIUsage(event.usage)
+				});
+				return chunks;
+			}
+			const choice = isRecord(choices[0]) ? choices[0] : {};
+			const delta = isRecord(choice.delta) ? choice.delta : {};
+			const reasoningDelta = stringValue(delta.reasoning) ?? stringValue(delta.reasoning_content) ?? "";
+			if (reasoningDelta !== "") {
+				chunks.push(...closeText());
+				if (reasoningIndex < 0) {
+					reasoningIndex = nextIndex++;
+					chunks.push({
+						type: "block-start",
+						index: reasoningIndex,
+						blockType: "reasoning"
+					});
+				}
+				reasoningContent += reasoningDelta;
+				chunks.push({
+					type: "reasoning-delta",
+					index: reasoningIndex,
+					text: reasoningDelta
+				});
+			}
+			const contentDelta = stringValue(delta.content) ?? "";
+			if (contentDelta !== "") {
+				chunks.push(...closeReasoning());
+				if (textIndex < 0) {
+					textIndex = nextIndex++;
+					chunks.push({
+						type: "block-start",
+						index: textIndex,
+						blockType: "text"
+					});
+				}
+				textContent += contentDelta;
+				sawContent = true;
+				chunks.push({
+					type: "text-delta",
+					index: textIndex,
+					text: contentDelta
+				});
+			}
+			if (Array.isArray(delta.tool_calls)) {
+				sawContent = true;
+				for (const rawCall of delta.tool_calls) {
+					if (!isRecord(rawCall)) continue;
+					const callIndex = numberValue(rawCall.index) ?? 0;
+					let existing = openAiToolCalls.find((call) => call.index === callIndex);
+					const fn = isRecord(rawCall.function) ? rawCall.function : void 0;
+					const id = stringValue(rawCall.id);
+					const name = fn === void 0 ? void 0 : stringValue(fn.name);
+					const argDelta = fn === void 0 ? void 0 : stringValue(fn.arguments) ?? (fn.arguments === void 0 ? "" : JSON.stringify(fn.arguments));
+					if (!existing) {
+						existing = {
+							index: callIndex,
+							name: name ?? "",
+							arguments: argDelta ?? ""
+						};
+						if (id !== void 0) existing.id = id;
+						openAiToolCalls.push(existing);
+					} else {
+						if (id !== void 0 && existing.id === void 0) existing.id = id;
+						if (name !== void 0 && existing.name === "") existing.name = name;
+						if (argDelta !== void 0) existing.arguments += argDelta;
+					}
+				}
+			}
+			if (choice.finish_reason !== void 0 && choice.finish_reason !== null) {
+				chunks.push(...closeText(), ...closeReasoning(), ...emitOpenAiToolCalls());
+				if (event.usage !== void 0) chunks.push({
+					type: "usage",
+					usage: mapOpenAIUsage(event.usage)
+				});
+				chunks.push({
+					type: "finish",
+					reason: mapOpenAIFinishReason(choice.finish_reason)
+				});
+			}
+			return chunks;
+		};
+		const handleEvent = (event) => protocol === "openai" ? handleOpenAIEvent(event) : handleCliEvent(event);
 		try {
 			let finished = false;
 			for (;;) {
@@ -1859,6 +2177,7 @@ var CommandCodeAdapter = class extends LlmAdapter {
 			if (!finished) {
 				yield* closeText();
 				yield* closeReasoning();
+				if (protocol === "openai") yield* emitOpenAiToolCalls();
 				if (!sawContent) throw new LlmError("Command Code returned an empty response；Command Code 返回了空响应，重试通常可恢复", "EMPTY_RESPONSE");
 				yield {
 					type: "finish",
@@ -1923,6 +2242,55 @@ function mapFinishReason(reason) {
 	if (reason === "length" || reason === "max_tokens" || reason === "max-tokens" || reason === "max_output_tokens") return { kind: "max-tokens" };
 	return { kind: "stop" };
 }
+function mapOpenAIFinishReason(reason) {
+	if (reason === "tool_calls" || reason === "tool-calls") return { kind: "tool-calls" };
+	if (reason === "length" || reason === "max_tokens" || reason === "max-tokens" || reason === "max_output_tokens") return { kind: "max-tokens" };
+	return { kind: "stop" };
+}
+/**
+* True when a Provider API pre-stream rejection is Command Code's Go-plan
+* gate (`upgrade_required`). Only this exact class of rejection should fall
+* back to the CLI /alpha/generate transport; other 4xx/5xx must surface as
+* ordinary errors so real account/model problems are not masked.
+*/
+function isUpgradeRequiredError(status, errText) {
+	if (status !== 403) return false;
+	const lower = errText.toLowerCase();
+	if (lower.includes("upgrade_required")) return true;
+	if (lower.includes("go plan") && lower.includes("api access")) return true;
+	if (lower.includes("only plan without api access")) return true;
+	if (lower.includes("upgrade to goat or higher")) return true;
+	try {
+		const parsed = JSON.parse(errText);
+		if (isRecord(parsed)) {
+			const error = isRecord(parsed.error) ? parsed.error : parsed;
+			if ((stringValue(error.code) ?? stringValue(error.type))?.toLowerCase() === "upgrade_required") return true;
+			const message = stringValue(error.message) ?? "";
+			if (message.toLowerCase().includes("go plan") && message.toLowerCase().includes("api access")) return true;
+		}
+	} catch {}
+	return false;
+}
+/** Map an OpenAI Chat Completions usage payload to harness disjoint counts. */
+function mapOpenAIUsage(usage) {
+	const source = isRecord(usage) ? usage : {};
+	const promptTokens = numberValue(source.prompt_tokens) ?? 0;
+	const outputTokens = numberValue(source.completion_tokens) ?? 0;
+	const totalTokens = numberValue(source.total_tokens);
+	const promptDetails = isRecord(source.prompt_tokens_details) ? source.prompt_tokens_details : void 0;
+	const cacheRead = numberValue(promptDetails?.cached_tokens) ?? 0;
+	const cacheWrite = numberValue(promptDetails?.cache_creation_input_tokens) ?? 0;
+	const reasoningTokens = numberValue((isRecord(source.completion_tokens_details) ? source.completion_tokens_details : void 0)?.reasoning_tokens);
+	const usageOut = {
+		inputTokens: Math.max(0, promptTokens - cacheRead - cacheWrite),
+		outputTokens,
+		cacheReadTokens: cacheRead
+	};
+	if (cacheWrite > 0) usageOut.cacheWriteTokens = cacheWrite;
+	if (reasoningTokens !== void 0) usageOut.reasoningTokens = reasoningTokens;
+	if (totalTokens !== void 0) usageOut.totalTokens = totalTokens;
+	return usageOut;
+}
 //#endregion
 //#region src/command-locales.ts
 const commandcodeCommand = {