@gajae-code/ai 0.14.2 → 0.15.0

package/src/providers/anthropic.ts

@@ -81,6 +81,7 @@ import {
 	parseStreamingJson,
 } from "../utils/json-parse";
 import { parseGitHubCopilotApiKey } from "../utils/oauth/github-copilot";
+import { GLM_ZCODE_ANTHROPIC_BASE_URL } from "../utils/oauth/glm-zcode";
 import { notifyProviderResponse } from "../utils/provider-response";
 import { isCopilotTransientModelError } from "../utils/retry";
 import { getRetryAfterMsFromHeaders } from "../utils/retry-after";
@@ -1144,6 +1145,29 @@ type FoundryTlsOptions = {
 	key?: string;
 };
 
+export function resolveGlmZcodeAnthropicBaseUrl(): string {
+	const configured = $credentialEnv("ZCODE_PLAN_ANTHROPIC_BASE_URL")?.trim();
+	if (!configured || /[\u0000-\u001f\u007f-\u009f]/u.test(configured)) {
+		return GLM_ZCODE_ANTHROPIC_BASE_URL;
+	}
+	try {
+		const parsed = new URL(configured);
+		if (
+			parsed.protocol !== "https:" ||
+			parsed.hostname.length === 0 ||
+			parsed.username.length > 0 ||
+			parsed.password.length > 0 ||
+			parsed.search.length > 0 ||
+			parsed.hash.length > 0
+		) {
+			return GLM_ZCODE_ANTHROPIC_BASE_URL;
+		}
+		return normalizeAnthropicBaseUrl(parsed.toString()) ?? GLM_ZCODE_ANTHROPIC_BASE_URL;
+	} catch {
+		return GLM_ZCODE_ANTHROPIC_BASE_URL;
+	}
+}
+
 function resolveAnthropicBaseUrl(model: Model<"anthropic-messages">, apiKey?: string): string | undefined {
 	if (model.provider === "github-copilot") {
 		return normalizeAnthropicBaseUrl(resolveGitHubCopilotBaseUrl(model.baseUrl, apiKey) ?? model.baseUrl);
@@ -1152,9 +1176,7 @@ function resolveAnthropicBaseUrl(model: Model<"anthropic-messages">, apiKey?: st
 	// calls api.z.ai directly (no zcode.z.ai gateway, no captcha). Pin the base so dynamic
 	// discovery / stale bundled catalogs / model cache can't redirect it elsewhere.
 	if (model.provider === "glm-zcode") {
-		return (
-			normalizeAnthropicBaseUrl($credentialEnv("ZCODE_PLAN_ANTHROPIC_BASE_URL")) ?? "https://api.z.ai/api/anthropic"
-		);
+		return resolveGlmZcodeAnthropicBaseUrl();
 	}
 	if (model.provider === "anthropic" && isFoundryEnabled()) {
 		const foundryBaseUrl = normalizeAnthropicBaseUrl($credentialEnv("FOUNDRY_BASE_URL"));
@@ -2023,7 +2045,21 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			const blocks = output.content as Block[];
 			const blocksByAnthropicIndex = new Map<number, Block>();
 			const truncatedToolCalls = new Set<ToolCall>();
-			let sawTerminalStopReason = false;
+			// Bounded diagnostic for degraded primitive increments: at most one
+			// warning per delta type per stream invocation, naming only the
+			// envelope shape (delta type and received typeof) — never the payload.
+			const degradedIncrementDiagnostics = new Set<string>();
+			const noteDegradedIncrement = (deltaType: string, received: unknown): void => {
+				if (degradedIncrementDiagnostics.has(deltaType)) return;
+				degradedIncrementDiagnostics.add(deltaType);
+				logger.warn("anthropic: degraded non-string stream increment to empty string", {
+					model: model.id,
+					provider: model.provider,
+					deltaType,
+					receivedType: received === null ? "null" : typeof received,
+				});
+			};
+
 			// 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
@@ -2037,25 +2073,18 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				return { block, contentIndex: blocks.indexOf(block) };
 			};
 			const trackBlockByAnthropicIndex = (anthropicIndex: number, block: Block) => {
-				// A duplicate start for an active index is a provider-envelope violation;
-				// finalize the orphaned block so no internal stream fields leak into output.
 				const orphaned = blocksByAnthropicIndex.get(anthropicIndex);
 				if (orphaned) {
 					if (orphaned.type === "toolCall") {
-						if (!isCompleteJson(orphaned.partialJson)) {
-							orphaned.incompleteArguments = true;
-							orphaned.incompleteArgumentsReason = "truncated";
-							truncatedToolCalls.add(orphaned);
-						}
-						if (orphaned.partialJson.trim()) {
-							orphaned.arguments = parseStreamingJson(orphaned.partialJson);
-							if (findUnnecessaryUnicodeEscape(orphaned.partialJson)) {
-								orphaned.escapedNonAsciiArguments = true;
-							}
-						}
+						orphaned.incompleteArguments = true;
+						orphaned.incompleteArgumentsReason = "ambiguous";
+						truncatedToolCalls.add(orphaned);
+					}
+					if (block.type === "toolCall") {
+						block.incompleteArguments = true;
+						block.incompleteArgumentsReason = "ambiguous";
 					}
-					delete (orphaned as { index?: number }).index;
-					delete (orphaned as { partialJson?: string }).partialJson;
+					throw new Error("Anthropic stream reused an active content block index");
 				}
 				blocksByAnthropicIndex.set(anthropicIndex, block);
 			};
@@ -2070,7 +2099,6 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				output.stopReason = "stop";
 				firstTokenTime = undefined;
 				truncatedToolCalls.clear();
-				sawTerminalStopReason = false;
 			};
 			const idleTimeoutMs =
 				options?.streamIdleTimeoutMs ??
@@ -2105,7 +2133,6 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				// Retries reset output.content; drop stale block correlations from the aborted attempt.
 				blocksByAnthropicIndex.clear();
 				truncatedToolCalls.clear();
-				sawTerminalStopReason = false;
 				activeAbortTracker = createAbortSourceTracker(options?.signal);
 				let firstEventTimeoutAbortError: FirstEventTimeoutError | undefined;
 				const idleTimeoutAbortError = new Error("Anthropic stream stalled while waiting for the next event");
@@ -2253,13 +2280,21 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 								trackBlockByAnthropicIndex(event.index, block);
 							} else if (event.content_block.type === "tool_use") {
 								streamedReplayUnsafeContent = true;
+								const initialArguments: unknown = event.content_block.input;
+								if (
+									initialArguments === null ||
+									typeof initialArguments !== "object" ||
+									Array.isArray(initialArguments)
+								) {
+									throw new Error("Anthropic tool_use started with non-object arguments");
+								}
 								const block: Block = {
 									type: "toolCall",
 									id: event.content_block.id,
 									name: isOAuthToken
 										? stripClaudeToolPrefix(event.content_block.name)
 										: event.content_block.name,
-									arguments: (event.content_block.input as Record<string, unknown>) ?? {},
+									arguments: initialArguments as Record<string, unknown>,
 									partialJson: "",
 									index: event.index,
 								};
@@ -2275,32 +2310,42 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							if (event.delta.type === "text_delta") {
 								const { block, contentIndex: index } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "text") {
-									block.text += event.delta.text;
+									const rawTextDelta: unknown = event.delta.text;
+									if (typeof rawTextDelta !== "string") {
+										noteDegradedIncrement("text_delta", rawTextDelta);
+									}
+									const textDelta = typeof rawTextDelta === "string" ? rawTextDelta : "";
+									block.text += textDelta;
 									stream.push({
 										type: "text_delta",
 										contentIndex: index,
-										delta: event.delta.text,
+										delta: textDelta,
 										partial: output,
 									});
 								}
 							} else if (event.delta.type === "thinking_delta") {
 								const { block, contentIndex: index } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "thinking") {
-									block.thinking += event.delta.thinking;
+									const rawThinkingDelta: unknown = event.delta.thinking;
+									if (typeof rawThinkingDelta !== "string") {
+										noteDegradedIncrement("thinking_delta", rawThinkingDelta);
+									}
+									const thinkingDelta = typeof rawThinkingDelta === "string" ? rawThinkingDelta : "";
+									block.thinking += thinkingDelta;
 									if (summarizedThinking) {
-										const summary = (reasoningBuffers.get(block) ?? "") + event.delta.thinking;
+										const summary = (reasoningBuffers.get(block) ?? "") + thinkingDelta;
 										reasoningBuffers.set(block, summary);
 										stream.push({
 											type: "reasoning_summary_delta",
 											contentIndex: index,
-											delta: event.delta.thinking,
+											delta: thinkingDelta,
 											partial: output,
 										});
 									} else {
 										stream.push({
 											type: "thinking_delta",
 											contentIndex: index,
-											delta: event.delta.thinking,
+											delta: thinkingDelta,
 											partial: output,
 										});
 									}
@@ -2308,12 +2353,26 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							} else if (event.delta.type === "input_json_delta") {
 								const { block, contentIndex: index } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "toolCall") {
-									block.partialJson += event.delta.partial_json;
+									const rawJsonDelta: unknown = event.delta.partial_json;
+									if (typeof rawJsonDelta !== "string") {
+										// Tool-argument fragments are positional JSON text: erasing or
+										// coercing any malformed increment (primitive OR object/function)
+										// assembles valid-but-wrong arguments — e.g. `{"n":1` + numeric
+										// primitive erased to "" + `3}` parses as {"n":13} and executes.
+										// Prose/thinking/signature anomalies are safe to degrade; tool
+										// arguments fail the turn closed. The payload never enters the
+										// error.
+										throw new Error(
+											"Anthropic stream sent a non-string input_json_delta tool-argument increment; failing the turn instead of assembling wrong tool arguments",
+										);
+									}
+									const jsonDelta = rawJsonDelta;
+									block.partialJson += jsonDelta;
 									block.arguments = parseStreamingJson(block.partialJson);
 									stream.push({
 										type: "toolcall_delta",
 										contentIndex: index,
-										delta: event.delta.partial_json,
+										delta: jsonDelta,
 										partial: output,
 									});
 								}
@@ -2321,7 +2380,12 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 								const { block } = getBlockByAnthropicIndex(event.index);
 								if (block && block.type === "thinking") {
 									block.thinkingSignature = block.thinkingSignature || "";
-									block.thinkingSignature += event.delta.signature;
+									const rawSignatureDelta: unknown = event.delta.signature;
+									if (typeof rawSignatureDelta === "string") {
+										block.thinkingSignature += rawSignatureDelta;
+									} else {
+										noteDegradedIncrement("signature_delta", rawSignatureDelta);
+									}
 								}
 							}
 						} else if (event.type === "content_block_stop") {
@@ -2359,9 +2423,21 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 										partial: output,
 									});
 								} else if (block.type === "toolCall") {
-									if (!isCompleteJson(block.partialJson)) truncatedToolCalls.add(block);
+									if (!isCompleteJson(block.partialJson)) {
+										truncatedToolCalls.add(block);
+										block.incompleteArguments = true;
+										block.incompleteArgumentsReason = "truncated";
+									}
 									if (block.partialJson.trim()) {
-										block.arguments = parseStreamingJson(block.partialJson);
+										const parsedArguments: unknown = parseStreamingJson(block.partialJson);
+										if (
+											parsedArguments === null ||
+											typeof parsedArguments !== "object" ||
+											Array.isArray(parsedArguments)
+										) {
+											throw new Error("Anthropic tool_use completed with non-object arguments");
+										}
+										block.arguments = parsedArguments as Record<string, unknown>;
 										if (findUnnecessaryUnicodeEscape(block.partialJson)) {
 											block.escapedNonAsciiArguments = true;
 										}
@@ -2383,7 +2459,6 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							if (rawStopReason) {
 								output.stopReason = isProviderSafetyStop ? "error" : mapStopReason(rawStopReason);
 								sawTerminalEnvelope = true;
-								sawTerminalStopReason = true;
 							}
 							if (isProviderSafetyStop) {
 								sawProviderSafetyStop = true;
@@ -2852,6 +2927,8 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				delete (block as { index?: number }).index;
 				if (block.type === "toolCall") {
 					truncatedToolCalls.add(block);
+					block.incompleteArguments = true;
+					block.incompleteArgumentsReason = "truncated";
 					if (block.partialJson.trim()) {
 						block.arguments = parseStreamingJson(block.partialJson);
 						if (findUnnecessaryUnicodeEscape(block.partialJson)) {
@@ -2862,12 +2939,10 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				}
 			}
 			blocksByAnthropicIndex.clear();
-			if (output.stopReason === "length" || !sawTerminalStopReason) {
-				for (const block of output.content) {
-					if (block.type === "toolCall" && truncatedToolCalls.has(block)) {
-						block.incompleteArguments = true;
-						block.incompleteArgumentsReason = "truncated";
-					}
+			for (const block of output.content) {
+				if (block.type === "toolCall" && truncatedToolCalls.has(block)) {
+					block.incompleteArguments = true;
+					block.incompleteArgumentsReason = "truncated";
 				}
 			}
 			output.duration = Date.now() - startTime;

package/src/providers/aws-credential-config.ts

@@ -1,7 +1,6 @@
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import { $credentialEnv } from "@gajae-code/utils";
+import { $credentialEnv, getTrustedHomeDir } from "@gajae-code/utils";
 import type { AwsCredentials } from "./aws-sigv4";
 
 export type AwsIniFile = Record<string, Record<string, string>>;
@@ -64,7 +63,7 @@ export function parseAwsIni(text: string): AwsIniFile {
 
 export function resolveAwsCredentialSource(options: AwsCredentialSourceOptions = {}): AwsCredentialSource {
 	const profile = options.profile || $credentialEnv("AWS_PROFILE") || "default";
-	const home = os.homedir();
+	const home = getTrustedHomeDir();
 	return {
 		profile,
 		credentialsPath: path.resolve(

package/src/providers/aws-credentials.ts

@@ -20,9 +20,8 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import { $env, isEnoent, logger } from "@gajae-code/utils";
+import { $env, getTrustedHomeDir, isEnoent, logger } from "@gajae-code/utils";
 import {
 	type AwsIniFile,
 	classifyAwsProfileCapability,
@@ -201,7 +200,7 @@ async function loadSsoCachedToken(
 	startUrl: string,
 	sessionName: string | undefined,
 ): Promise<SsoCachedToken | undefined> {
-	const cacheDir = path.join(os.homedir(), ".aws", "sso", "cache");
+	const cacheDir = path.join(getTrustedHomeDir(), ".aws", "sso", "cache");
 	let entries: string[];
 	try {
 		entries = await fs.promises.readdir(cacheDir);

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

@@ -15,6 +15,7 @@ import type {
 	StreamOptions,
 	Tool,
 	ToolChoice,
+	ToolResultMessage,
 } from "../types";
 import { normalizeSystemPrompts } from "../utils";
 import { createAbortSourceTracker } from "../utils/abort";
@@ -396,7 +397,23 @@ function convertMessages(
 	}
 
 	let msgIndex = 0;
+	// Consecutive tool results are batched into one append call so every output
+	// of the turn stays contiguous before the collected image user message;
+	// per-result image user messages interleave with sibling outputs and break
+	// tool_use→tool_result adjacency through Anthropic-translating proxies (#4807).
+	let pendingToolResults: ToolResultMessage[] = [];
+	const flushPendingToolResults = (): void => {
+		if (pendingToolResults.length === 0) return;
+		appendResponsesToolResultMessages(messages, pendingToolResults, model, strictResponsesPairing, knownCallIds);
+		pendingToolResults = [];
+	};
 	for (const msg of transformedMessages) {
+		if (msg.role === "toolResult") {
+			pendingToolResults.push(msg);
+			msgIndex++;
+			continue;
+		}
+		flushPendingToolResults();
 		if (msg.role === "user" || msg.role === "developer") {
 			const content = convertResponsesInputContent(msg.content, model.input.includes("image"));
 			if (!content) continue;
@@ -408,11 +425,10 @@ function convertMessages(
 			const outputItems = convertResponsesAssistantMessage(msg as AssistantMessage, model, msgIndex, knownCallIds);
 			if (outputItems.length === 0) continue;
 			messages.push(...outputItems);
-		} else if (msg.role === "toolResult") {
-			appendResponsesToolResultMessages(messages, msg, model, strictResponsesPairing, knownCallIds);
 		}
 		msgIndex++;
 	}
+	flushPendingToolResults();
 
 	return messages;
 }