@gajae-code/ai 0.12.0 → 0.12.2

package/src/providers/anthropic.ts

@@ -20,7 +20,11 @@ import {
 	logger,
 	readSseEvents,
 } from "@gajae-code/utils";
-import { hasOpus47ApiRestrictions, mapEffortToAnthropicAdaptiveEffort } from "../model-thinking";
+import {
+	hasOpus47ApiRestrictions,
+	mapEffortToAnthropicAdaptiveEffort,
+	supportsAnthropicAdaptiveThinkingDisplay as supportsAdaptiveThinkingDisplay,
+} from "../model-thinking";
 import { calculateCost } from "../models";
 import { isUsageLimitError } from "../rate-limit-utils";
 import { getEnvApiKey, OUTPUT_FALLBACK_BUFFER } from "../stream";
@@ -62,12 +66,13 @@ import { transportFailureFacts } from "../utils/fallback-transport";
 import { isFoundryEnabled } from "../utils/foundry";
 import { finalizeErrorMessage, type RawHttpRequestDump, rewriteCopilotError } from "../utils/http-inspector";
 import {
+	FirstEventTimeoutError,
 	getProviderFirstEventTimeoutFallbackMs,
 	getStreamFirstEventTimeoutMs,
 	getStreamIdleTimeoutMs,
 	iterateWithIdleTimeout,
 } from "../utils/idle-iterator";
-import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse";
+import { isCompleteJson, parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { isCopilotTransientModelError } from "../utils/retry";
@@ -309,22 +314,6 @@ type AnthropicSamplingParams = MessageCreateParamsStreaming & {
 const ANTHROPIC_STOP_SEQUENCES_MAX = 4;
 let warnedStopSequencesTrim = false;
 
-/**
- * Adaptive thinking `display` is supported starting with Anthropic model Opus 4.7.
- * Older adaptive-thinking models (Opus 4.6, Sonnet 4.6+) reject the field.
- * Fable (5+) postdates Opus 4.7, accepts `display`, and defaults it to
- * "omitted" — thinking tokens are billed but no content streams back — so it
- * must opt in like Opus 4.7+ (issue #2791).
- */
-function supportsAdaptiveThinkingDisplay(modelId: string): boolean {
-	if (/claude-fable-\d/.test(modelId)) return true;
-	const match = /claude-opus-(\d+)-(\d+)/.exec(modelId);
-	if (!match) return false;
-	const major = Number(match[1]);
-	const minor = Number(match[2]);
-	return major > 4 || (major === 4 && minor >= 7);
-}
-
 const ANTHROPIC_PROVIDER_SESSION_STATE_KEY = "anthropic-messages";
 
 type AnthropicProviderSessionState = ProviderSessionState & {
@@ -1422,6 +1411,8 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			) & { index: number };
 			const blocks = output.content as Block[];
 			const blocksByAnthropicIndex = new Map<number, Block>();
+			const truncatedToolCalls = new Set<ToolCall>();
+			let sawTerminalStopReason = false;
 			// Derive from the ACTUAL request shape, not the option default: the request
 			// only sends `display: "summarized"` on specific paths (adaptive display is
 			// omitted for models where supportsAdaptiveThinkingDisplay is false). Defaulting
@@ -1439,8 +1430,14 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				// finalize the orphaned block so no internal stream fields leak into output.
 				const orphaned = blocksByAnthropicIndex.get(anthropicIndex);
 				if (orphaned) {
-					if (orphaned.type === "toolCall" && orphaned.partialJson.trim()) {
-						orphaned.arguments = parseStreamingJson(orphaned.partialJson);
+					if (orphaned.type === "toolCall") {
+						if (!isCompleteJson(orphaned.partialJson)) {
+							orphaned.incompleteArguments = true;
+							truncatedToolCalls.add(orphaned);
+						}
+						if (orphaned.partialJson.trim()) {
+							orphaned.arguments = parseStreamingJson(orphaned.partialJson);
+						}
 					}
 					delete (orphaned as { index?: number }).index;
 					delete (orphaned as { partialJson?: string }).partialJson;
@@ -1457,6 +1454,8 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
 				output.stopReason = "stop";
 				firstTokenTime = undefined;
+				truncatedToolCalls.clear();
+				sawTerminalStopReason = false;
 			};
 			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getStreamIdleTimeoutMs();
 			const firstEventFallbackMs = getProviderFirstEventTimeoutFallbackMs(model.provider);
@@ -1467,12 +1466,13 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			// Provider-level transport/rate-limit failures: only before any streamed content starts.
 			// Malformed envelopes/JSON: only before replay-unsafe text/tool events are visible on this stream.
 			let providerRetryAttempt = 0;
-			let thinkingRepairAttempted = false;
 			while (true) {
 				// Retries reset output.content; drop stale block correlations from the aborted attempt.
 				blocksByAnthropicIndex.clear();
+				truncatedToolCalls.clear();
+				sawTerminalStopReason = false;
 				activeAbortTracker = createAbortSourceTracker(options?.signal);
-				const firstEventTimeoutAbortError = new Error(
+				const firstEventTimeoutAbortError = new FirstEventTimeoutError(
 					"Anthropic stream timed out while waiting for the first event",
 				);
 				const idleTimeoutAbortError = new Error("Anthropic stream stalled while waiting for the next event");
@@ -1495,6 +1495,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					let sawEvent = false;
 					let sawMessageStart = false;
 					let sawTerminalEnvelope = false;
+					let sawMessageStop = false;
 					const isProgressEvent = createAnthropicStreamProgressPredicate();
 
 					for await (const event of iterateWithIdleTimeout(anthropicStream, {
@@ -1508,9 +1509,13 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						isProgressItem: isProgressEvent,
 					})) {
 						sawEvent = true;
+						if (sawMessageStop) {
+							throw createAnthropicStreamEnvelopeError("received event after message_stop");
+						}
 						if (sawProviderSafetyStop) {
 							if (event.type === "message_stop") {
 								sawTerminalEnvelope = true;
+								sawMessageStop = true;
 							}
 							continue;
 						}
@@ -1698,6 +1703,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 										partial: output,
 									});
 								} else if (block.type === "toolCall") {
+									if (!isCompleteJson(block.partialJson)) truncatedToolCalls.add(block);
 									if (block.partialJson.trim()) {
 										block.arguments = parseStreamingJson(block.partialJson);
 									}
@@ -1718,6 +1724,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							if (rawStopReason) {
 								output.stopReason = isProviderSafetyStop ? "error" : mapStopReason(rawStopReason);
 								sawTerminalEnvelope = true;
+								sawTerminalStopReason = true;
 							}
 							if (isProviderSafetyStop) {
 								sawProviderSafetyStop = true;
@@ -1759,6 +1766,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							calculateCost(model, output.usage);
 						} else if (event.type === "message_stop") {
 							sawTerminalEnvelope = true;
+							sawMessageStop = true;
 						}
 					}
 
@@ -1781,8 +1789,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					}
 					break;
 				} catch (streamError) {
-					const streamFailure = activeAbortTracker.getLocalAbortReason() ?? streamError;
-					if (sawProviderSafetyStop) {
+					const localAbortReason = activeAbortTracker.getLocalAbortReason();
+					const streamFailure = localAbortReason ?? streamError;
+					if (localAbortReason || sawProviderSafetyStop) {
 						throw streamFailure;
 					}
 					if (
@@ -1834,21 +1843,22 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					const thinkingSignatureInvalid = isAnthropicThinkingSignatureInvalidError(streamFailure);
 					if (
 						!options?.fallbackManaged &&
-						!thinkingRepairAttempted &&
+						!repairAllAssistantThinking &&
 						firstTokenTime === undefined &&
 						(thinkingSignatureInvalid || isAnthropicThinkingBlockMutationError(streamFailure))
 					) {
+						// The mutation 400 blames the "latest assistant message", but its cited
+						// `messages.N.content.M` path can point at an EARLIER replayed turn, so the
+						// latest-only repair gets rejected identically. Escalate to the full-history
+						// repair instead of burning the single retry on one scope.
+						const escalateToAll: boolean = thinkingSignatureInvalid || repairLatestAssistantThinking;
 						logger.debug("anthropic: repairing assistant thinking replay after provider rejection", {
 							model: model.id,
-							scope: thinkingSignatureInvalid ? "all" : "latest",
+							scope: escalateToAll ? "all" : "latest",
 							error: streamFailure instanceof Error ? streamFailure.message : String(streamFailure),
 						});
-						thinkingRepairAttempted = true;
-						if (thinkingSignatureInvalid) {
-							repairAllAssistantThinking = true;
-						} else {
-							repairLatestAssistantThinking = true;
-						}
+						repairLatestAssistantThinking = !escalateToAll;
+						repairAllAssistantThinking = escalateToAll;
 						params = await prepareParams();
 						providerRetryAttempt = 0;
 						resetOutputForRetry();
@@ -1897,6 +1907,24 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				}
 			}
 
+			for (const block of blocksByAnthropicIndex.values()) {
+				delete (block as { index?: number }).index;
+				if (block.type === "toolCall") {
+					truncatedToolCalls.add(block);
+					if (block.partialJson.trim()) {
+						block.arguments = parseStreamingJson(block.partialJson);
+					}
+					delete (block as { partialJson?: string }).partialJson;
+				}
+			}
+			blocksByAnthropicIndex.clear();
+			if (output.stopReason === "length" || !sawTerminalStopReason) {
+				for (const block of output.content) {
+					if (block.type === "toolCall" && truncatedToolCalls.has(block)) {
+						block.incompleteArguments = true;
+					}
+				}
+			}
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) output.ttft = firstTokenTime - startTime;
 			if (dropFastMode && resolveServiceTier(options?.serviceTier, model.provider) === "priority") {
@@ -1909,13 +1937,12 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				delete (block as { index?: number }).index;
 				delete (block as { partialJson?: string }).partialJson;
 			}
-			const firstEventTimeoutError = activeAbortTracker.getLocalAbortReason();
+			const localAbortReason = activeAbortTracker.getLocalAbortReason();
 			output.stopReason = activeAbortTracker.wasCallerAbort() ? "aborted" : "error";
-			output.errorStatus = extractHttpStatusFromError(error);
-			output.transportFailure = transportFailureFacts(error);
+			output.errorStatus = extractHttpStatusFromError(localAbortReason ?? error);
+			output.transportFailure = transportFailureFacts(localAbortReason ?? error);
 			if (output.errorKind !== "provider_safety_stop" || !output.errorMessage) {
-				output.errorMessage =
-					firstEventTimeoutError?.message ?? (await finalizeErrorMessage(error, rawRequestDump));
+				output.errorMessage = localAbortReason?.message ?? (await finalizeErrorMessage(error, rawRequestDump));
 			}
 			output.errorMessage = rewriteCopilotError(output.errorMessage, error, model.provider);
 			output.duration = Date.now() - startTime;
@@ -2100,13 +2127,26 @@ function createClient(
 	return { client, isOAuthToken: oauthToken };
 }
 
-function disableThinkingIfToolChoiceForced(params: MessageCreateParamsStreaming): void {
+/**
+ * Anthropic rejects extended thinking combined with a forced tool choice, so such a
+ * request drops `thinking`/`output_config`. Reports whether the forced-choice branch
+ * applied so the caller can keep the replayed history consistent with it.
+ */
+function disableThinkingIfToolChoiceForced(params: MessageCreateParamsStreaming): boolean {
 	const toolChoice = params.tool_choice;
-	if (!toolChoice) return;
-	if (toolChoice.type === "any" || toolChoice.type === "tool") {
-		delete params.thinking;
-		delete params.output_config;
-	}
+	if (!toolChoice) return false;
+	if (toolChoice.type !== "any" && toolChoice.type !== "tool") return false;
+	delete params.thinking;
+	delete params.output_config;
+	return true;
+}
+
+function hasNativeThinkingBlocks(messages: MessageParam[]): boolean {
+	return messages.some(
+		message =>
+			Array.isArray(message.content) &&
+			message.content.some(block => block.type === "thinking" || block.type === "redacted_thinking"),
+	);
 }
 
 function mapAnthropicToolChoice(
@@ -2430,6 +2470,18 @@ function buildParams(
 		}
 	}
 
+	// A forced tool choice strips `thinking` from the request. Signed thinking blocks
+	// replayed from history belong to a thinking-enabled request, and Anthropic rejects
+	// that pair with `thinking`/`redacted_thinking` blocks "cannot be modified", so the
+	// replay has to degrade in the same rebuild. Runs before the billing/system payload
+	// snapshot so the attribution hash covers the messages actually sent.
+	if (disableThinkingIfToolChoiceForced(params) && hasNativeThinkingBlocks(params.messages)) {
+		params.messages = convertAnthropicMessages(context.messages, model, isOAuthToken, {
+			...thinkingRepair,
+			repairAllAssistantThinking: true,
+		});
+	}
+
 	const shouldInjectClaudeCodeInstruction = isOAuthToken && !model.id.startsWith("claude-3-5-haiku");
 	const billingSystemPrompts = normalizeSystemPrompts(context.systemPrompt);
 	const billingPayload = shouldInjectClaudeCodeInstruction
@@ -2445,7 +2497,6 @@ function buildParams(
 	if (systemBlocks) {
 		params.system = systemBlocks;
 	}
-	disableThinkingIfToolChoiceForced(params);
 	ensureMaxTokensForThinking(params, model);
 	applyPromptCaching(params as AnthropicCacheParams, cacheMode, cacheControl);
 	enforceCacheControlLimit(params, 4);

package/src/providers/azure-openai-responses.ts

@@ -22,7 +22,6 @@ import { AssistantMessageEventStream } from "../utils/event-stream";
 import { transportFailureFacts } from "../utils/fallback-transport";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
 import {
-	createWatchdog,
 	getOpenAIStreamIdleTimeoutMs,
 	getStreamFirstEventTimeoutMs,
 	iterateWithIdleTimeout,
@@ -118,7 +117,6 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 		);
 		let rawRequestDump: RawHttpRequestDump | undefined;
 		const abortTracker = createAbortSourceTracker(options?.signal);
-		const firstEventTimeoutAbortError = new Error(AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE);
 		const { requestAbortController, requestSignal } = abortTracker;
 
 		try {
@@ -127,7 +125,7 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 			const client = createClient(model, apiKey, options);
 			const { baseUrl } = resolveAzureConfig(model, options);
 			const params = buildParams(model, context, options, deploymentName, baseUrl);
-			const idleTimeoutMs = getOpenAIStreamIdleTimeoutMs();
+			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
 			options?.onPayload?.(params);
 			rawRequestDump = {
 				provider: model.provider,
@@ -164,18 +162,17 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 				rawRequestDump = { ...rawRequestDump, body: params };
 				openaiStream = await client.responses.create(params, { signal: requestSignal });
 			}
-			const firstEventWatchdog = createWatchdog(
-				options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs),
-				() => abortTracker.abortLocally(firstEventTimeoutAbortError),
-			);
+			const firstEventTimeoutMs = options?.streamFirstEventTimeoutMs ?? getStreamFirstEventTimeoutMs(idleTimeoutMs);
 			stream.push({ type: "start", partial: output });
 
 			await processResponsesStream(
 				iterateWithIdleTimeout(openaiStream, {
-					watchdog: firstEventWatchdog,
+					firstItemTimeoutMs: firstEventTimeoutMs,
+					firstItemErrorMessage: AZURE_OPENAI_RESPONSES_FIRST_EVENT_TIMEOUT_MESSAGE,
 					idleTimeoutMs,
 					errorMessage: "Azure OpenAI responses stream stalled while waiting for the next event",
 					onIdle: () => requestAbortController.abort(),
+					onFirstItemTimeout: () => requestAbortController.abort(),
 				}),
 				output,
 				stream,
@@ -272,16 +269,31 @@ export function resolveAzureConfigForTest(
 	return resolveAzureConfig(model, options);
 }
 
+/**
+ * Azure API key for the client, from trusted environment sources only.
+ *
+ * `$env` merges the caller's `cwd/.env`, so reading the key there would let
+ * repository content supply the credential this client authenticates with.
+ * Provider credentials are resolved from the launching shell plus GJC/user-owned
+ * `.env` files, never the project `.env` — this fallback now matches that rule.
+ */
+function resolveAzureClientApiKey(apiKey: string): string | undefined {
+	if (apiKey) return apiKey;
+	return $credentialEnv("AZURE_OPENAI_API_KEY");
+}
+
+/** Test seam: the client API key as resolved from a caller value plus trusted env. */
+export function resolveAzureClientApiKeyForTest(apiKey: string): string | undefined {
+	return resolveAzureClientApiKey(apiKey);
+}
 function createClient(model: Model<"azure-openai-responses">, apiKey: string, options?: AzureOpenAIResponsesOptions) {
-	if (!apiKey) {
-		const envKey = $env.AZURE_OPENAI_API_KEY;
-		if (!envKey) {
-			throw new Error(
-				"Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.",
-			);
-		}
-		apiKey = envKey;
+	const resolvedApiKey = resolveAzureClientApiKey(apiKey);
+	if (!resolvedApiKey) {
+		throw new Error(
+			"Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY environment variable or pass it as an argument.",
+		);
 	}
+	apiKey = resolvedApiKey;
 
 	const headers = { ...(model.headers ?? {}) };
 

package/src/providers/google-vertex.ts

@@ -1,4 +1,4 @@
-import { $credentialEnv, $env } from "@gajae-code/utils";
+import { $credentialEnv, $pickCredentialEnv } from "@gajae-code/utils";
 import type { Context, Model, StreamFunction } from "../types";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
 import { getVertexAccessToken } from "./google-auth";
@@ -72,7 +72,7 @@ function resolveApiKey(options?: GoogleVertexOptions): string | undefined {
 }
 
 function resolveProject(options?: GoogleVertexOptions): string {
-	const project = options?.project || $env.GOOGLE_CLOUD_PROJECT || $env.GCLOUD_PROJECT;
+	const project = options?.project || $pickCredentialEnv("GOOGLE_CLOUD_PROJECT", "GCLOUD_PROJECT");
 	if (!project) {
 		throw new Error(
 			"Vertex AI requires a project ID. Set GOOGLE_CLOUD_PROJECT/GCLOUD_PROJECT or pass project in options.",
@@ -84,10 +84,41 @@ function resolveProject(options?: GoogleVertexOptions): string {
 function resolveEndpointHost(location: string): string {
 	return location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
 }
+/**
+ * Vertex location, from trusted environment sources only and constrained to a
+ * region label.
+ *
+ * The location is interpolated into the request **host**
+ * (`${location}-aiplatform.googleapis.com`) as well as the path, and the request
+ * carries `Authorization: Bearer <accessToken>`. A value containing `/`
+ * terminates the authority component, so `evil.example.com/` resolves to origin
+ * `https://evil.example.com` and the Google access token leaves Google entirely.
+ * `$env` merges the caller's `cwd/.env`, so this was reachable from repository
+ * content.
+ *
+ * Both halves are needed: trusted resolution keeps a repository from setting it,
+ * and the shape check keeps any source from turning a region into an authority.
+ */
+const VERTEX_LOCATION_RE = /^[a-z0-9-]+$/;
+
+function assertVertexLocation(location: string): string {
+	if (!VERTEX_LOCATION_RE.test(location)) {
+		throw new Error(
+			`Invalid Vertex AI location ${JSON.stringify(location)}. Expected a region label such as "us-central1" or "global".`,
+		);
+	}
+	return location;
+}
+
 function resolveLocation(options?: GoogleVertexOptions): string {
-	const location = options?.location || $env.GOOGLE_CLOUD_LOCATION;
+	const location = options?.location || $credentialEnv("GOOGLE_CLOUD_LOCATION");
 	if (!location) {
 		throw new Error("Vertex AI requires a location. Set GOOGLE_CLOUD_LOCATION or pass location in options.");
 	}
-	return location;
+	return assertVertexLocation(location);
+}
+
+/** Test seam: the Vertex location as resolved from options plus trusted env. */
+export function resolveVertexLocationForTest(options?: GoogleVertexOptions): string {
+	return resolveLocation(options);
 }

package/src/providers/ollama.ts

@@ -18,7 +18,7 @@ import { normalizeSystemPrompts } from "../utils";
 import { AssistantMessageEventStream } from "../utils/event-stream";
 import { transportFailureFacts } from "../utils/fallback-transport";
 import { finalizeErrorMessage, type RawHttpRequestDump } from "../utils/http-inspector";
-import { parseStreamingJson } from "../utils/json-parse";
+import { isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { resolveRetryBudget } from "../utils/retry-budget";
 import { flattenToolRootCombinators, toolWireSchema } from "../utils/schema";
 import {
@@ -26,6 +26,7 @@ import {
 	markToolChoiceIncapability,
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
+import { flagTruncatedToolCalls } from "./openai-responses-shared";
 import { transformMessages } from "./transform-messages";
 
 export interface OllamaChatOptions extends StreamOptions {
@@ -357,8 +358,10 @@ function endToolCallBlock(stream: AssistantMessageEventStream, output: Assistant
 		return;
 	}
 	const toolCall = block as InternalToolCallBlock;
-	if (toolCall.partialJson) {
-		toolCall.arguments = parseStreamingJson<Record<string, unknown>>(toolCall.partialJson);
+	if (toolCall.partialJson !== undefined) {
+		if (toolCall.partialJson.trim()) {
+			toolCall.arguments = parseStreamingJson<Record<string, unknown>>(toolCall.partialJson);
+		}
 		delete toolCall.partialJson;
 	}
 	stream.push({ type: "toolcall_end", contentIndex: index, toolCall, partial: output });
@@ -393,6 +396,8 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 		let activeThinkingIndex: number | undefined;
 		let activeTextIndex: number | undefined;
 		const activeToolIndices = new Set<number>();
+		const unverifiableArgumentToolCallIds = new Set<string>();
+		let sawTerminalChunk = false;
 		try {
 			const apiKey = options.apiKey || getEnvApiKey(model.provider);
 			if (!apiKey) {
@@ -537,6 +542,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 					for (const call of chunk.message.tool_calls) {
 						const name = call.function?.name ?? "unknown_tool";
 						const rawArgs = call.function?.arguments;
+						const unverifiableArguments = typeof rawArgs !== "string";
 						const partialJson = typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs ?? {});
 						const toolCall: InternalToolCallBlock = {
 							type: "toolCall",
@@ -545,6 +551,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 							arguments: parseStreamingJson<Record<string, unknown>>(partialJson),
 							partialJson,
 						};
+						if (unverifiableArguments) unverifiableArgumentToolCallIds.add(toolCall.id);
 						output.content.push(toolCall);
 						const index = output.content.length - 1;
 						activeToolIndices.add(index);
@@ -561,6 +568,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 					}
 				}
 				if (chunk.done) {
+					sawTerminalChunk = true;
 					if (activeThinkingIndex !== undefined) {
 						endThinkingBlock(stream, output, activeThinkingIndex);
 						activeThinkingIndex = undefined;
@@ -569,16 +577,36 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 						endTextBlock(stream, output, activeTextIndex);
 						activeTextIndex = undefined;
 					}
+					output.stopReason = mapDoneReason(chunk.done_reason, output);
+					// Ollama still owns every partialJson buffer here; use the helper's
+					// finalized-call branch before endToolCallBlock deletes those buffers.
+					// Non-string arguments have no raw completion evidence, so a length stop
+					// must fail closed rather than trusting normalized or re-serialized values.
+					flagTruncatedToolCalls(
+						output,
+						output.stopReason,
+						block => !unverifiableArgumentToolCallIds.has(block.id),
+					);
+					if (chunk.done_reason === undefined) {
+						for (const block of output.content) {
+							if (block.type !== "toolCall") continue;
+							const partialJson = (block as InternalToolCallBlock).partialJson;
+							if (partialJson !== undefined && !isCompleteJson(partialJson)) block.incompleteArguments = true;
+						}
+					}
 					for (const index of activeToolIndices) {
 						endToolCallBlock(stream, output, index);
 					}
 					activeToolIndices.clear();
-					output.stopReason = mapDoneReason(chunk.done_reason, output);
 					output.usage.input = chunk.prompt_eval_count ?? 0;
 					output.usage.output = chunk.eval_count ?? 0;
 					output.usage.totalTokens = output.usage.input + output.usage.output;
+					break;
 				}
 			}
+			if (!sawTerminalChunk) {
+				throw new Error("Ollama stream ended before terminal done chunk");
+			}
 			output.duration = Date.now() - startTime;
 			if (firstTokenTime) {
 				output.ttft = firstTokenTime - startTime;