@gajae-code/ai 0.4.4 → 0.5.0

package/src/providers/cursor.ts

@@ -30,6 +30,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 import { parseStreamingJson } from "../utils/json-parse";
 import { formatErrorMessageWithRetryAfter } from "../utils/retry-after";
 import { toolWireSchema } from "../utils/schema/wire";
+import { COMPOSER_EDIT_DISCIPLINE_PROMPT, isComposerHarnessModel } from "./composer-discipline";
 import type { McpToolDefinition } from "./cursor/gen/agent_pb";
 import {
 	AgentClientMessageSchema,
@@ -569,7 +570,7 @@ export const streamCursor: StreamFunction<"cursor-agent"> = (
 	return stream;
 };
 
-type ToolCallState = ToolCall & { index: number; partialJson?: string; kind: "mcp" | "todo_write" };
+type ToolCallState = ToolCall & { index: number; partialJson?: string; kind: "mcp" | "todo_write" | "native" };
 
 interface BlockState {
 	currentTextBlock: (TextContent & { index: number }) | null;
@@ -1844,6 +1845,60 @@ function buildTodoWriteArgs(toolCall: CursorUpdateTodosToolCall): {
 	};
 }
 
+// Map a cursor ToolCall oneof field name (e.g. "shellToolCall") to a display tool
+// name. Mirrors cli-jaw's cursorToolKindLabel (src/agent/events/cursor.ts) so the
+// two surfaces label cursor-native tools identically.
+const CURSOR_NATIVE_KIND_ALIASES: Record<string, string> = {
+	shell: "bash",
+	read: "read",
+	write: "write",
+	delete: "delete",
+	edit: "edit",
+	grep: "grep",
+	glob: "glob",
+	ls: "ls",
+	semSearch: "codebase_search",
+	webSearch: "web_search",
+	fetch: "fetch",
+	task: "task",
+	createPlan: "create_plan",
+	askQuestion: "ask_question",
+	readLints: "read_lints",
+	applyAgentDiff: "apply_diff",
+};
+
+function cursorNativeToolName(kindKey: string): string {
+	const base = kindKey.replace(/ToolCall$/i, "");
+	if (!base) return "tool";
+	return CURSOR_NATIVE_KIND_ALIASES[base] ?? base;
+}
+
+// Cursor's model sometimes calls its own native IDE tools (shell/glob/grep/…)
+// instead of the advertised MCP tools. Those arrive as ToolCall oneof variants we
+// do not otherwise handle (everything except mcpToolCall / updateTodosToolCall), so
+// without this they are silently dropped and never render. Build a generic toolCall
+// block from whichever *ToolCall field is set so the call (and its result) is shown.
+function buildNativeToolCallBlock(
+	toolCall: Record<string, unknown>,
+	callId: string,
+	index: number,
+): ToolCallState | null {
+	for (const [key, payload] of Object.entries(toolCall)) {
+		if (!/ToolCall$/.test(key) || !payload || typeof payload !== "object") continue;
+		if (key === "mcpToolCall" || key === "updateTodosToolCall") continue;
+		const args = (payload as { args?: unknown }).args;
+		return {
+			type: "toolCall",
+			id: callId,
+			name: cursorNativeToolName(key),
+			arguments: args && typeof args === "object" ? (args as Record<string, unknown>) : { raw: payload },
+			index,
+			kind: "native",
+		};
+	}
+	return null;
+}
+
 function buildMcpResultFromToolResult(_mcpCall: CursorMcpCall, toolResult: ToolResultMessage) {
 	if (toolResult.isError) {
 		return buildMcpErrorResult(toolResultToText(toolResult) || "MCP tool failed");
@@ -1987,6 +2042,21 @@ function processInteractionUpdate(
 				output.content.push(block);
 				state.setToolCall(block);
 				stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
+				return;
+			}
+
+			// Fallback: cursor-native tool variants (shell/glob/grep/…) we don't model
+			// explicitly. Render them so the call and its result are visible instead of
+			// vanishing.
+			const nativeBlock = buildNativeToolCallBlock(
+				toolCall,
+				update.message.value.callId || crypto.randomUUID(),
+				output.content.length,
+			);
+			if (nativeBlock) {
+				output.content.push(nativeBlock);
+				state.setToolCall(nativeBlock);
+				stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
 			}
 		}
 	} else if (updateCase === "toolCallDelta" || updateCase === "partialToolCall") {
@@ -2215,12 +2285,18 @@ function findLastUserMessageIndex(messages: Message[]): number {
  * When no system prompts are provided, returns a single default greeting so we never emit
  * an empty `rootPromptMessagesJson` head.
  */
-export function buildCursorSystemPromptJsons(systemPrompt: readonly string[] | undefined): string[] {
+export function buildCursorSystemPromptJsons(systemPrompt: readonly string[] | undefined, modelId?: string): string[] {
 	const systemPrompts = normalizeSystemPrompts(systemPrompt);
 	if (systemPrompts.length === 0) {
 		return [JSON.stringify({ role: "system", content: "You are a helpful assistant." })];
 	}
-	return systemPrompts.map(content => JSON.stringify({ role: "system", content }));
+	const jsons = systemPrompts.map(content => JSON.stringify({ role: "system", content }));
+	// Composer-harness models need anchor/edit discipline pinned ahead of the
+	// host prompt (see composer-discipline.ts for the observed failure modes).
+	if (modelId !== undefined && isComposerHarnessModel(modelId)) {
+		jsons.unshift(JSON.stringify({ role: "system", content: COMPOSER_EDIT_DISCIPLINE_PROMPT }));
+	}
+	return jsons;
 }
 
 function buildRootPromptMessagesJson(
@@ -2432,7 +2508,7 @@ function buildGrpcRequest(
 } {
 	const blobStore = state.blobStore;
 
-	const systemPromptIds = buildCursorSystemPromptJsons(context.systemPrompt).map(json =>
+	const systemPromptIds = buildCursorSystemPromptJsons(context.systemPrompt, model.id).map(json =>
 		storeCursorBlob(blobStore, new TextEncoder().encode(json)),
 	);
 

package/src/providers/google-gemini-cli.ts

@@ -25,6 +25,11 @@ import { resolveRetryBudget } from "../utils/retry-budget";
 // Refresh is the sole responsibility of AuthStorage (broker-aware, single-flighted);
 // the stream provider trusts the access token threaded through `options.apiKey`.
 import { normalizeSchemaForCCA } from "../utils/schema";
+import {
+	isForcedToolChoiceUnsupportedError,
+	markToolChoiceIncapability,
+	resolveToolChoice,
+} from "../utils/tool-choice-capability";
 import { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders } from "./google-gemini-headers";
 import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "./google-shared";
 import {
@@ -48,7 +53,7 @@ import {
 export type { GoogleThinkingLevel };
 
 export interface GoogleGeminiCliOptions extends StreamOptions {
-	toolChoice?: "auto" | "none" | "any";
+	toolChoice?: "auto" | "none" | "any" | "required";
 	/**
 	 * Thinking/reasoning configuration.
 	 * - Gemini 2.x models: use `budgetTokens` to set the thinking budget
@@ -324,7 +329,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				...(needsClaudeThinkingBetaHeader(model) ? { "anthropic-beta": CLAUDE_THINKING_BETA_HEADER } : {}),
 				...(options?.headers ?? {}),
 			};
-			const requestBodyJson = JSON.stringify(requestBody);
+			let requestBodyJson = JSON.stringify(requestBody);
 			rawRequestDump = {
 				provider: model.provider,
 				api: output.api,
@@ -334,7 +339,13 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				headers: requestHeaders,
 			};
 
-			const response = await fetchWithRetry(
+			const sentForcedToolChoice =
+				(requestBody.request.toolConfig?.functionCallingConfig?.mode === "ANY" ||
+					requestBody.request.toolConfig?.functionCallingConfig?.mode === "VALIDATED") &&
+				options?.toolChoice !== undefined &&
+				options.toolChoice !== "auto" &&
+				options.toolChoice !== "none";
+			let response = await fetchWithRetry(
 				attempt => `${endpoints[Math.min(attempt, endpoints.length - 1)]}/v1internal:streamGenerateContent?alt=sse`,
 				{
 					method: "POST",
@@ -347,6 +358,49 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 					fetch: options?.fetch,
 				},
 			);
+			if (!response.ok && sentForcedToolChoice) {
+				const errorText = await response.text();
+				const error = withHttpStatus(
+					new Error(`Cloud Code Assist API error (${response.status}): ${extractErrorMessage(errorText)}`),
+					response.status,
+				);
+				if (firstTokenTime === undefined && isForcedToolChoiceUnsupportedError(error, true)) {
+					const beforeMark = resolveToolChoice(model, options?.toolChoice);
+					markToolChoiceIncapability(model, "auto", error.message);
+					stream.push({
+						type: "toolChoiceIncapability",
+						api: model.api,
+						provider: model.provider,
+						model: model.id,
+						requestedLevel: beforeMark.requestedLevel,
+						resolvedLevel: "auto",
+						reason: error.message,
+						registryKey: beforeMark.registryKey,
+					});
+					requestBody = {
+						...requestBody,
+						request: { ...requestBody.request, toolConfig: undefined },
+					};
+					requestBodyJson = JSON.stringify(requestBody);
+					rawRequestDump = { ...rawRequestDump, body: requestBody };
+					response = await fetchWithRetry(
+						attempt =>
+							`${endpoints[Math.min(attempt, endpoints.length - 1)]}/v1internal:streamGenerateContent?alt=sse`,
+						{
+							method: "POST",
+							headers: requestHeaders,
+							body: requestBodyJson,
+							signal: options?.signal,
+							maxAttempts: 1,
+							defaultDelayMs: attempt => BASE_DELAY_MS * 2 ** attempt,
+							maxDelayMs: options?.maxRetryDelayMs ?? RATE_LIMIT_BUDGET_MS,
+							fetch: options?.fetch,
+						},
+					);
+				} else {
+					throw error;
+				}
+			}
 			if (!response.ok) {
 				const errorText = await response.text();
 				throw withHttpStatus(
@@ -743,13 +797,15 @@ export function buildRequest(
 		request.generationConfig = generationConfig;
 	}
 
+	const resolvedToolChoice = resolveToolChoice(model, options.toolChoice);
 	if (context.tools && context.tools.length > 0) {
 		const convertedTools = convertTools(context.tools, model);
 		request.tools = isAntigravity ? normalizeAntigravityTools(convertedTools) : convertedTools;
-		if (options.toolChoice) {
+		const resolved = resolvedToolChoice;
+		if (resolved.resolvedChoice) {
 			request.toolConfig = {
 				functionCallingConfig: {
-					mode: mapToolChoice(options.toolChoice),
+					mode: mapToolChoice(resolved.resolvedChoice as string),
 				},
 			};
 		}
@@ -763,11 +819,14 @@ export function buildRequest(
 	}
 
 	if (isAntigravity && isClaudeModel(model.id)) {
-		request.toolConfig = {
-			functionCallingConfig: {
-				mode: "VALIDATED" as FunctionCallingConfigMode,
-			},
-		};
+		const resolvedLevel = resolvedToolChoice.resolvedLevel;
+		if (resolvedLevel === "named" || resolvedLevel === "required") {
+			request.toolConfig = {
+				functionCallingConfig: {
+					mode: "VALIDATED" as FunctionCallingConfigMode,
+				},
+			};
+		}
 	}
 
 	if (isAntigravity && shouldInjectAntigravitySystemInstruction(model.id)) {

package/src/providers/google-gemini-headers.ts

@@ -4,7 +4,7 @@
  * GeminiCLI/VERSION/MODEL (PLATFORM; ARCH; SURFACE)
  */
 export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
-	const version = process.env.PI_AI_GEMINI_CLI_VERSION || "0.45.2";
+	const version = process.env.PI_AI_GEMINI_CLI_VERSION || "0.46.0";
 	const platform = process.platform === "win32" ? "win32" : process.platform;
 	const arch = process.arch === "x64" ? "x64" : process.arch;
 	return `GeminiCLI/${version}/${modelId} (${platform}; ${arch}; terminal)`;

package/src/providers/google-shared.ts

@@ -22,6 +22,11 @@ import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { finalizeErrorMessage, type RawHttpRequestDump, withHttpStatus } from "../utils/http-inspector";
 import { normalizeSchemaForCCA, normalizeSchemaForGoogle, toolWireSchema } from "../utils/schema";
+import {
+	isForcedToolChoiceUnsupportedError,
+	markToolChoiceIncapability,
+	resolveToolChoice,
+} from "../utils/tool-choice-capability";
 import type {
 	Content,
 	FinishReason,
@@ -59,7 +64,7 @@ export type GoogleThinkingLevel = "THINKING_LEVEL_UNSPECIFIED" | "MINIMAL" | "LO
  * `google-gemini-cli` uses a different transport and request shape — do not extend this for it.
  */
 export interface GoogleSharedStreamOptions extends StreamOptions {
-	toolChoice?: "auto" | "none" | "any";
+	toolChoice?: "auto" | "none" | "any" | "required";
 	thinking?: {
 		enabled: boolean;
 		budgetTokens?: number;
@@ -366,6 +371,7 @@ export function mapToolChoice(choice: string): FunctionCallingConfigMode {
 		case "none":
 			return "NONE";
 		case "any":
+		case "required":
 			return "ANY";
 		default:
 			return "AUTO";
@@ -689,14 +695,15 @@ export function buildGoogleGenerateContentParams<T extends "google-generative-ai
 		...(context.tools && context.tools.length > 0 && { tools: convertTools(context.tools, model) }),
 	};
 
-	if (context.tools && context.tools.length > 0 && options.toolChoice) {
-		config.toolConfig = {
-			functionCallingConfig: {
-				mode: mapToolChoice(options.toolChoice),
-			},
-		};
-	} else {
-		config.toolConfig = undefined;
+	if (context.tools && context.tools.length > 0) {
+		const resolved = resolveToolChoice(model, options.toolChoice);
+		if (resolved.resolvedChoice) {
+			config.toolConfig = {
+				functionCallingConfig: {
+					mode: mapToolChoice(resolved.resolvedChoice as string),
+				},
+			};
+		}
 	}
 
 	if (options.thinking?.enabled && model.reasoning) {
@@ -789,14 +796,56 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 				headers: plan.headers,
 			};
 
-			const wireBody = paramsToWireBody(params);
+			let wireBody = paramsToWireBody(params);
+			const sentForcedToolChoice =
+				(params.config?.toolConfig?.functionCallingConfig?.mode === "ANY" ||
+					params.config?.toolConfig?.functionCallingConfig?.mode === "VALIDATED") &&
+				options?.toolChoice !== undefined &&
+				options.toolChoice !== "auto" &&
+				options.toolChoice !== "none";
 			const fetchImpl = plan.fetch ?? options?.fetch ?? (globalThis.fetch.bind(globalThis) as FetchImpl);
-			const response = await fetchImpl(plan.url, {
+			let response = await fetchImpl(plan.url, {
 				method: "POST",
 				headers: { ...plan.headers, "Content-Type": "application/json", Accept: "text/event-stream" },
 				body: JSON.stringify(wireBody),
 				signal: options?.signal,
 			});
+			if (!response.ok && sentForcedToolChoice) {
+				const errorText = await response.text().catch(() => "");
+				const error = withHttpStatus(
+					new Error(`Google API error (${response.status}): ${extractGoogleErrorMessage(errorText)}`),
+					response.status,
+				);
+				if (firstTokenTime === undefined && isForcedToolChoiceUnsupportedError(error, true)) {
+					const beforeMark = resolveToolChoice(model, options?.toolChoice);
+					markToolChoiceIncapability(model, "auto", error.message);
+					stream.push({
+						type: "toolChoiceIncapability",
+						api: model.api,
+						provider: model.provider,
+						model: model.id,
+						requestedLevel: beforeMark.requestedLevel,
+						resolvedLevel: "auto",
+						reason: error.message,
+						registryKey: beforeMark.registryKey,
+					});
+					const retryParams = {
+						...params,
+						config: params.config ? { ...params.config, toolConfig: undefined } : params.config,
+					};
+					params = retryParams;
+					rawRequestDump = { ...rawRequestDump, body: params };
+					wireBody = paramsToWireBody(params);
+					response = await fetchImpl(plan.url, {
+						method: "POST",
+						headers: { ...plan.headers, "Content-Type": "application/json", Accept: "text/event-stream" },
+						body: JSON.stringify(wireBody),
+						signal: options?.signal,
+					});
+				} else {
+					throw error;
+				}
+			}
 			if (!response.ok) {
 				const errorText = await response.text().catch(() => "");
 				throw withHttpStatus(
@@ -857,7 +906,7 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
  * `abortSignal` is intentionally dropped — the SDK propagates it via `fetch.signal`,
  * which our caller already wires up through `options.signal`.
  */
-function paramsToWireBody(params: GenerateContentParameters): Record<string, unknown> {
+export function paramsToWireBody(params: GenerateContentParameters): Record<string, unknown> {
 	const body: Record<string, unknown> = { contents: params.contents };
 	const config = params.config;
 	if (!config) return body;

package/src/providers/ollama.ts

@@ -20,6 +20,11 @@ import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-ins
 import { parseStreamingJson } from "../utils/json-parse";
 import { resolveRetryBudget } from "../utils/retry-budget";
 import { toolWireSchema } from "../utils/schema/wire";
+import {
+	isForcedToolChoiceUnsupportedError,
+	markToolChoiceIncapability,
+	resolveToolChoice,
+} from "../utils/tool-choice-capability";
 import { transformMessages } from "./transform-messages";
 
 export interface OllamaChatOptions extends StreamOptions {
@@ -253,10 +258,22 @@ function convertTools(tools: Tool[] | undefined): OllamaFunctionTool[] | undefin
 	}));
 }
 
-function createChatBody(model: Model<"ollama-chat">, context: Context, options: OllamaChatOptions | undefined) {
+export function createChatBody(model: Model<"ollama-chat">, context: Context, options: OllamaChatOptions | undefined) {
 	const think = mapReasoning(options?.reasoning);
-	const toolChoice = mapToolChoice(options?.toolChoice);
-	const selectedTools = selectToolsForToolChoice(context.tools, options?.toolChoice);
+	const resolved = resolveToolChoice(model, options?.toolChoice);
+	const toolChoice = mapToolChoice(resolved.resolvedChoice);
+
+	// Ollama's wire protocol has no named forcing — a named request rides
+	// `tool_choice: "required"` with the tool list narrowed to the target
+	// (issue #1236). Narrow whenever the resolved choice still forces a tool.
+	const shouldNarrowToNamedTool =
+		resolved.requestedLevel === "named" &&
+		(resolved.resolvedLevel === "named" || resolved.resolvedLevel === "required") &&
+		resolved.targetToolName !== undefined;
+	const selectedTools =
+		shouldNarrowToNamedTool && resolved.targetToolName
+			? selectToolsForToolChoice(context.tools, { type: "tool", name: resolved.targetToolName })
+			: context.tools;
 	const tools = convertTools(selectedTools);
 	return {
 		model: model.id,
@@ -382,6 +399,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			}
 			const baseUrl = normalizeBaseUrl(model.baseUrl);
 			let body = createChatBody(model, context, options);
+			const sentForcedToolChoice = body.tool_choice === "required";
 			const replacementPayload = await options.onPayload?.(body, model);
 			if (replacementPayload !== undefined) {
 				body = replacementPayload as typeof body;
@@ -394,7 +412,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 				url: `${baseUrl}/api/chat`,
 				body,
 			};
-			const response = await fetchWithRetry(`${baseUrl}/api/chat`, {
+			let response = await fetchWithRetry(`${baseUrl}/api/chat`, {
 				method: "POST",
 				headers: {
 					...model.headers,
@@ -408,6 +426,44 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 				defaultDelayMs: OLLAMA_RETRY_DELAYS_MS,
 				fetch: options.fetch,
 			});
+			if (!response.ok && sentForcedToolChoice) {
+				const error = new Error(
+					`HTTP ${response.status} from ${baseUrl}/api/chat: ${await response.text().catch(() => "")}`,
+				);
+				(error as Error & { status?: number }).status = response.status;
+				if (firstTokenTime === undefined && isForcedToolChoiceUnsupportedError(error, true)) {
+					markToolChoiceIncapability(model, "auto", error.message);
+					stream.push({
+						type: "toolChoiceIncapability",
+						api: model.api,
+						provider: model.provider,
+						model: model.id,
+						requestedLevel: "required",
+						resolvedLevel: "auto",
+						reason: error.message,
+						registryKey: resolveToolChoice(model, options?.toolChoice).registryKey,
+					});
+					body = { ...body };
+					delete (body as { tool_choice?: unknown }).tool_choice;
+					rawRequestDump = { ...rawRequestDump, body };
+					response = await fetchWithRetry(`${baseUrl}/api/chat`, {
+						method: "POST",
+						headers: {
+							...model.headers,
+							...options.headers,
+							Authorization: `Bearer ${apiKey}`,
+							"Content-Type": "application/json",
+						},
+						body: JSON.stringify(body),
+						signal: options.signal,
+						maxAttempts: 1,
+						defaultDelayMs: OLLAMA_RETRY_DELAYS_MS,
+						fetch: options.fetch,
+					});
+				} else {
+					throw error;
+				}
+			}
 			if (!response.ok) {
 				throw new Error(`HTTP ${response.status} from ${baseUrl}/api/chat`);
 			}