@gajae-code/ai 0.15.3 → 0.15.5

package/src/providers/kiro-codewhisperer.d.ts

@@ -1,5 +1,8 @@
+import type { Effort } from "../model-thinking";
 import type { StreamFunction, StreamOptions } from "../types";
 export interface KiroCodeWhispererOptions extends StreamOptions {
+    /** Effort level for Kiro API-key reasoning. */
+    reasoning?: Effort | boolean;
     /** AWS region for the CodeWhisperer streaming endpoint. */
     region?: string;
     /** Profile ARN for enterprise IAM Identity Center accounts. */

package/src/providers/kiro-codewhisperer.ts

@@ -11,6 +11,7 @@
  * not from any AGPL reference implementation.
  */
 import { $credentialEnv, $env, extractHttpStatusFromError } from "@gajae-code/utils";
+import type { Effort } from "../model-thinking";
 import type {
 	Api,
 	AssistantMessage,
@@ -28,12 +29,15 @@ import { transportFailureFacts } from "../utils/fallback-transport";
 import { withHttpStatus } from "../utils/http-inspector";
 import { captureUnicodeEscapeEvidence } from "../utils/json-parse";
 import { decodeEventStream } from "./aws-eventstream";
+import { isKiroApiKey, streamKiroApiKey } from "./kiro-api-key";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Provider options
 // ─────────────────────────────────────────────────────────────────────────────
 
 export interface KiroCodeWhispererOptions extends StreamOptions {
+	/** Effort level for Kiro API-key reasoning. */
+	reasoning?: Effort | boolean;
 	/** AWS region for the CodeWhisperer streaming endpoint. */
 	region?: string;
 	/** Profile ARN for enterprise IAM Identity Center accounts. */
@@ -143,6 +147,11 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 	context: Context,
 	options: KiroCodeWhispererOptions,
 ): AssistantMessageEventStream => {
+	const token = resolveBearerToken(options.apiKey);
+	if (isKiroApiKey(token)) {
+		return streamKiroApiKey(model, context, { ...options, apiKey: token });
+	}
+
 	const stream = new AssistantMessageEventStream();
 
 	(async () => {
@@ -175,7 +184,7 @@ export const streamKiroCodeWhisperer: StreamFunction<"kiro-codewhisperer-stream"
 			const bearerToken = resolveBearerToken(options.apiKey);
 			if (!bearerToken) {
 				throw new Error(
-					"No Kiro credentials found. Run 'gjc auth-broker login kiro' to authenticate via AWS Builder ID, or set AWS_BEARER_TOKEN_KIRO.",
+					"No Kiro credentials found. Set KIRO_API_KEY (ksk_ from https://app.kiro.dev/settings/api-keys) or run 'gjc auth-broker login kiro'.",
 				);
 			}
 
@@ -541,7 +550,7 @@ function handleToolUseEvent(
 
 function resolveBearerToken(apiKey: string | undefined): string | undefined {
 	if (!apiKey) {
-		return $credentialEnv("AWS_BEARER_TOKEN_KIRO") ?? undefined;
+		return $credentialEnv("KIRO_API_KEY") ?? $credentialEnv("AWS_BEARER_TOKEN_KIRO") ?? undefined;
 	}
 
 	// Structured API key (from getOAuthApiKey) contains the access token as JSON

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

@@ -1571,6 +1571,8 @@ function handleOutputItemDone(
 			arguments: terminalArguments as Record<string, unknown>,
 		};
 		captureUnicodeEscapeEvidence(toolCall, item.arguments);
+		delete runtime.currentBlock.escapedNonAsciiArguments;
+		delete runtime.currentBlock.escapedUnicodeArgumentEvidence;
 		Object.assign(runtime.currentBlock, toolCall);
 		captureUnicodeEscapeEvidence(runtime.currentBlock, item.arguments);
 		delete (runtime.currentBlock as { partialJson?: string }).partialJson;
@@ -1625,6 +1627,8 @@ function handleOutputItemDone(
 			arguments: { input: terminalInput },
 			customWireName: item.name,
 		};
+		delete runtime.currentBlock.escapedNonAsciiArguments;
+		delete runtime.currentBlock.escapedUnicodeArgumentEvidence;
 		Object.assign(runtime.currentBlock, toolCall);
 		delete (runtime.currentBlock as { partialJson?: string }).partialJson;
 		delete (runtime.currentBlock as { doneInput?: string }).doneInput;

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

@@ -31,6 +31,7 @@ import {
 } from "../types";
 import { normalizeResponsesToolCallId, sanitizeJsonStrings } from "../utils";
 import type { AssistantMessageEventStream } from "../utils/event-stream";
+import { SERVER_OVERLOADED_PROVIDER_CODE } from "../utils/fallback-transport";
 import { captureUnicodeEscapeEvidence, isCompleteJson, parseStreamingJson } from "../utils/json-parse";
 import { areJsonValuesEqual } from "../utils/schema";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER, partitionVisionContent } from "./vision-guard";
@@ -981,7 +982,10 @@ export async function processResponsesStream<TApi extends Api>(
 						: typeof statusDetailsReason === "string" && statusDetailsReason.length > 0
 							? `status_details: ${statusDetailsReason}`
 							: "Unknown error (no error details in response)";
-				throw new Error(message);
+				// A `cancelled` response is not a capacity rejection and may already
+				// have produced observable work, so only the `failed` status carries
+				// the typed code onward.
+				throw createResponsesFailedError(message, response.status === "failed" ? error?.code : undefined);
 			}
 			// A response cut short for length (`incomplete`) may have stopped
 			// mid-tool-call. Any tool-call item still tracked in `items` never
@@ -1003,11 +1007,28 @@ export async function processResponsesStream<TApi extends Api>(
 				: details?.reason
 					? `incomplete: ${details.reason}`
 					: "Unknown error (no error details in response)";
-			throw new Error(message);
+			throw createResponsesFailedError(message, error?.code);
 		}
 	}
 }
 
+/**
+ * A terminal failure envelope arrives inside an HTTP 200 stream — as
+ * `response.failed`, or as `response.completed` with a `failed` response status
+ * — so the typed `error.code` is the only structured evidence the transport can
+ * keep. Both shapes carry the same structured failure and are typed identically.
+ * Exactly OpenAI's capacity-overload code is carried through as transport facts,
+ * matched case-sensitively; every other failure stays a plain error, so an
+ * untyped, cased, or malformed code can never reach a typed retry admission. The
+ * display message is unchanged either way.
+ */
+function createResponsesFailedError(message: string, code: string | undefined): Error {
+	if (code !== SERVER_OVERLOADED_PROVIDER_CODE) return new Error(message);
+	const error = new Error(message) as Error & { openaiErrorCode?: string };
+	error.openaiErrorCode = SERVER_OVERLOADED_PROVIDER_CODE;
+	return error;
+}
+
 /**
  * Whether two raw JSON argument strings decode to the same value. Used to tell a
  * relay's re-serialization of the same tool arguments apart from a genuine

package/src/stream.ts

@@ -131,10 +131,12 @@ const serviceProviderMap: Record<string, KeyResolver> = {
 	tavily: "TAVILY_API_KEY",
 	parallel: "PARALLEL_API_KEY",
 	kagi: "KAGI_API_KEY",
-	// Kiro uses AWS SSO OIDC OAuth flow; bearer token is stored as the OAuth access token.
+	// Kiro API keys use the ksk_ prefix; preserve the AWS bearer fallback for OAuth.
 	kiro: () => {
-		const bearerToken = $credentialEnv("AWS_BEARER_TOKEN_KIRO");
-		if (bearerToken) return bearerToken;
+		const apiKey = $credentialEnv("KIRO_API_KEY");
+		return apiKey?.trim().startsWith("ksk_") && !/[\x00-\x1f\x7f]/.test(apiKey)
+			? apiKey
+			: $credentialEnv("AWS_BEARER_TOKEN_KIRO");
 	},
 	// GitHub Copilot uses GitHub personal access token
 	"github-copilot": () => $pickCredentialEnv("COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"),

package/src/types.d.ts

@@ -399,31 +399,22 @@ export interface ToolCall {
      */
     incompleteArgumentsReason?: "truncated" | "malformed" | "conflicting" | "ambiguous";
     /**
-     * Set when the raw argument JSON spelled a printable character as a `\uXXXX`
-     * escape instead of a literal character. This includes ASCII landings because
-     * a one-nibble mutation can move an intended non-ASCII scalar below U+0080.
-     * Such a payload parses cleanly but
-     * is unverifiable: one mistyped hex digit decodes to a different, equally
-     * valid character, so the text can be silently wrong with no in-band evidence.
-     * The agent loop resamples the turn a bounded number of times and then
-     * rejects the call instead of executing it. The single bounded exception
-     * is a tool that enumerated its display-only fields
-     * (`displaySafeEscapedArgFields`): when every escaped scalar corroborates
-     * a decoded non-ASCII character inside those fields, the call executes
-     * with a warning instead — rendered question text, never executable
-     * content, ids, or durable metadata.
-     * Escapes that are required (control characters) or unavoidable (lone
-     * surrogates) never set this.
+     * Set by current producers when raw argument JSON carries unsafe Unicode
+     * data, such as malformed escape evidence or a decoded unpaired surrogate.
+     * Valid JSON `\uXXXX` escapes are canonical spellings of the decoded string
+     * and current producers do not set this flag for them.
+     *
+     * Legacy producers may still set the flag for any escaped non-ASCII spelling.
+     * The agent loop keeps its bounded legacy resample/display-safe behavior for
+     * those calls while consuming the transient evidence below.
      */
     escapedNonAsciiArguments?: boolean;
     /**
-     * Bounded, payload-free evidence for the original raw escape positions and
-     * process-keyed scalar/path identities. Required for the display-safe terminal exemption: decoded values
-     * alone cannot prove that an ASCII landing such as `\u0077` was not a
-     * one-nibble mutation of a non-ASCII escape. Presence of this evidence implies
-     * the guarded state even if a legacy producer omitted
-     * `escapedNonAsciiArguments`. The agent consumes and removes this transient
-     * field before the tool-call message can become durable.
+     * Bounded, payload-free evidence for raw Unicode argument data. Current
+     * producers attach it only for unsafe data; legacy producers may attach
+     * non-malformed positional evidence used by the display-safe compatibility
+     * path. The agent consumes and removes this transient field before the
+     * tool-call message can become durable.
      */
     escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;
 }
@@ -630,7 +621,7 @@ export type TSchema = ZodType | TJsonSchema;
 export type Static<S> = S extends ZodType ? z.infer<S> : S extends {
     static: infer T;
 } ? T : unknown;
-export type RawArgumentRejectionCode = "ask-intent-review-requires-positive-round" | "ask-intent-contract-requires-non-empty-authority" | "ask-deep-interview-metadata-requires-deep-interview-gate" | "ask-round-zero-metadata-requires-full-topology-fields" | "todo-write-unknown-root-key" | "todo-write-unknown-op-entry-key" | "todo-write-unknown-op-value" | "todo-write-done-drop-requires-target" | "todo-write-unknown-init-entry-key";
+export type RawArgumentRejectionCode = "ask-deep-interview-question-body-required" | "ask-intent-review-requires-positive-round" | "ask-intent-contract-requires-non-empty-authority" | "ask-deep-interview-metadata-requires-deep-interview-gate" | "ask-round-zero-metadata-requires-full-topology-fields" | "todo-write-unknown-root-key" | "todo-write-unknown-op-entry-key" | "todo-write-unknown-op-value" | "todo-write-done-drop-requires-target" | "todo-write-unknown-init-entry-key";
 /**
  * Optional structured detail attached to a raw-argument rejection. The fixed
  * per-code guidance in `RAW_ARGUMENT_REJECTION_MESSAGES` explains the shape;

package/src/types.ts

@@ -620,31 +620,22 @@ export interface ToolCall {
 	 */
 	incompleteArgumentsReason?: "truncated" | "malformed" | "conflicting" | "ambiguous";
 	/**
-	 * Set when the raw argument JSON spelled a printable character as a `\uXXXX`
-	 * escape instead of a literal character. This includes ASCII landings because
-	 * a one-nibble mutation can move an intended non-ASCII scalar below U+0080.
-	 * Such a payload parses cleanly but
-	 * is unverifiable: one mistyped hex digit decodes to a different, equally
-	 * valid character, so the text can be silently wrong with no in-band evidence.
-	 * The agent loop resamples the turn a bounded number of times and then
-	 * rejects the call instead of executing it. The single bounded exception
-	 * is a tool that enumerated its display-only fields
-	 * (`displaySafeEscapedArgFields`): when every escaped scalar corroborates
-	 * a decoded non-ASCII character inside those fields, the call executes
-	 * with a warning instead — rendered question text, never executable
-	 * content, ids, or durable metadata.
-	 * Escapes that are required (control characters) or unavoidable (lone
-	 * surrogates) never set this.
+	 * Set by current producers when raw argument JSON carries unsafe Unicode
+	 * data, such as malformed escape evidence or a decoded unpaired surrogate.
+	 * Valid JSON `\uXXXX` escapes are canonical spellings of the decoded string
+	 * and current producers do not set this flag for them.
+	 *
+	 * Legacy producers may still set the flag for any escaped non-ASCII spelling.
+	 * The agent loop keeps its bounded legacy resample/display-safe behavior for
+	 * those calls while consuming the transient evidence below.
 	 */
 	escapedNonAsciiArguments?: boolean;
 	/**
-	 * Bounded, payload-free evidence for the original raw escape positions and
-	 * process-keyed scalar/path identities. Required for the display-safe terminal exemption: decoded values
-	 * alone cannot prove that an ASCII landing such as `\u0077` was not a
-	 * one-nibble mutation of a non-ASCII escape. Presence of this evidence implies
-	 * the guarded state even if a legacy producer omitted
-	 * `escapedNonAsciiArguments`. The agent consumes and removes this transient
-	 * field before the tool-call message can become durable.
+	 * Bounded, payload-free evidence for raw Unicode argument data. Current
+	 * producers attach it only for unsafe data; legacy producers may attach
+	 * non-malformed positional evidence used by the display-safe compatibility
+	 * path. The agent consumes and removes this transient field before the
+	 * tool-call message can become durable.
 	 */
 	escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;
 }
@@ -871,6 +862,7 @@ export type TSchema = ZodType | TJsonSchema;
 export type Static<S> = S extends ZodType ? z.infer<S> : S extends { static: infer T } ? T : unknown;
 
 export type RawArgumentRejectionCode =
+	| "ask-deep-interview-question-body-required"
 	| "ask-intent-review-requires-positive-round"
 	| "ask-intent-contract-requires-non-empty-authority"
 	| "ask-deep-interview-metadata-requires-deep-interview-gate"

package/src/utils/fallback-transport.d.ts

@@ -23,6 +23,13 @@ export interface FallbackTrigger {
 export declare const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
 /** Stable code for a nominally successful response with no content or token usage. */
 export declare const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
+ * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the
+ * code itself is the only structured evidence of the failure and must survive
+ * the existence gate below. It is always compared case-sensitively.
+ */
+export declare const SERVER_OVERLOADED_PROVIDER_CODE = "server_is_overloaded";
 export type TransportHeaders = Headers | Record<string, string | undefined>;
 /**
  * Structured facts from an upstream HTTP or transport failure. Retry decisions

package/src/utils/fallback-transport.ts

@@ -26,6 +26,13 @@ export interface FallbackTrigger {
 export const STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE = "stream_first_event_timeout";
 /** Stable code for a nominally successful response with no content or token usage. */
 export const EMPTY_RESPONSE_PROVIDER_CODE = "empty_response";
+/**
+ * OpenAI's typed capacity-overload code. It arrives without an HTTP status —
+ * inside an HTTP 200 terminal Responses envelope or a Codex error event — so the
+ * code itself is the only structured evidence of the failure and must survive
+ * the existence gate below. It is always compared case-sensitively.
+ */
+export const SERVER_OVERLOADED_PROVIDER_CODE = "server_is_overloaded";
 
 export type TransportHeaders = Headers | Record<string, string | undefined>;
 
@@ -241,6 +248,11 @@ export function transportFailureFacts(
 		!isContextOverflowCode(normalizedCode) &&
 		normalizedCode !== STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE &&
 		normalizedCode !== EMPTY_RESPONSE_PROVIDER_CODE &&
+		// Matched case-sensitively against the raw code: this is the one gate a
+		// provider-owned code can open on its own, so a cased or padded variant
+		// must not materialize facts that would disqualify an unrelated
+		// bare-default retry.
+		providerCode !== SERVER_OVERLOADED_PROVIDER_CODE &&
 		requestBytes === undefined &&
 		firstEventElapsedMs === undefined &&
 		firstEventTimeoutMs === undefined &&
@@ -360,12 +372,17 @@ export function classifyFallbackTrigger(
 	const retryAfterMs =
 		parseRetryAfterMilliseconds(headers?.get("retry-after-ms") ?? null) ??
 		parseRetryAfterSeconds(headers?.get("retry-after") ?? null);
-	const codes = [facts.openaiErrorCode, facts.anthropicErrorType, facts.providerCode].map(value =>
-		value?.toLowerCase(),
-	);
+	const rawCodes = [facts.openaiErrorCode, facts.anthropicErrorType, facts.providerCode];
+	const codes = rawCodes.map(value => value?.toLowerCase());
 	const code = codes[0] ?? codes[1] ?? codes[2];
+	// The capacity-overload code is provider-owned and is the only code that can
+	// classify without a status, so it is matched case-sensitively — the same
+	// exactness the parser and the session admission use.
+	const rawCode = rawCodes[0] ?? rawCodes[1] ?? rawCodes[2];
 	const triggerClass: FallbackTriggerClass =
-		code === STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE || code === EMPTY_RESPONSE_PROVIDER_CODE
+		code === STREAM_FIRST_EVENT_TIMEOUT_PROVIDER_CODE ||
+		code === EMPTY_RESPONSE_PROVIDER_CODE ||
+		(facts.status === undefined && rawCode === SERVER_OVERLOADED_PROVIDER_CODE)
 			? "server"
 			: isQuotaCode(code)
 				? "quota"

package/src/utils/idle-iterator.ts

@@ -5,6 +5,11 @@ const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 120_000;
 const DEFAULT_STREAM_FIRST_EVENT_TIMEOUT_MS = 100_000;
 const ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS = 600_000;
 const KIMI_CODE_FIRST_EVENT_TIMEOUT_MS = 300_000;
+// Local LM Studio models can spend several minutes loading weights and filling
+// the prompt before emitting their first SSE event. Keep the shared default
+// for other OpenAI-compatible providers, but avoid aborting legitimate local
+// inference during that startup window.
+const LM_STUDIO_FIRST_EVENT_TIMEOUT_MS = 300_000;
 // Ollama Cloud is a hosted proxy where queueing/cold-start plus long prefill
 // (thinking-mode requests over 1M-context sessions) routinely exceeds 120s before
 // the first streamed token; 300s matches kimi-code's floor for long-reasoning silence.
@@ -34,6 +39,7 @@ export function isGrokModelId(modelId: string | undefined): boolean {
 
 export function getProviderFirstEventTimeoutFallbackMs(provider: string): number | undefined {
 	if (provider === "alibaba-token-plan") return ALIBABA_TOKEN_PLAN_FIRST_EVENT_TIMEOUT_MS;
+	if (provider === "lm-studio") return LM_STUDIO_FIRST_EVENT_TIMEOUT_MS;
 	if (provider === "ollama-cloud") return OLLAMA_CLOUD_FIRST_EVENT_TIMEOUT_MS;
 	return provider === "kimi-code" ? KIMI_CODE_FIRST_EVENT_TIMEOUT_MS : undefined;
 }

package/src/utils/json-parse.d.ts

@@ -67,9 +67,11 @@ export declare function collectUnicodeEscapeEvidence(json: string): UnicodeEscap
 /**
  * Return evidence only when decoded tool arguments are unsafe to execute.
  *
- * Valid JSON escapes and literal UTF-8 have the same canonical decoded value.
- * Malformed JSON, duplicate/deep evidence, and unpaired UTF-16 surrogates keep
- * the existing fail-closed path.
+ * Valid JSON escapes and literal UTF-8 have the same canonical decoded value,
+ * including a valid scalar whose hex digits differ from what a caller intended:
+ * runtime syntax validation cannot infer author intent after decoding.
+ * Malformed escape-bearing JSON, duplicate/deep suspicious escape evidence, and
+ * unpaired UTF-16 surrogates keep the fail-closed path.
  */
 export declare function collectUnsafeUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidence | undefined;
 /** Attach unsafe raw evidence while preserving the existing call-level guard flag. */

package/src/utils/json-parse.ts

@@ -486,15 +486,13 @@ export function collectUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidenc
 
 function hasUnpairedUnicodeSurrogate(value: unknown): boolean {
 	const pending: unknown[] = [value];
-	const seen = new WeakSet<object>();
 	while (pending.length > 0) {
 		const current = pending.pop();
 		if (typeof current === "string") {
 			if (!current.isWellFormed()) return true;
 			continue;
 		}
-		if (typeof current !== "object" || current === null || seen.has(current)) continue;
-		seen.add(current);
+		if (typeof current !== "object" || current === null) continue;
 		if (Array.isArray(current)) {
 			for (const child of current) pending.push(child);
 			continue;
@@ -510,9 +508,11 @@ function hasUnpairedUnicodeSurrogate(value: unknown): boolean {
 /**
  * Return evidence only when decoded tool arguments are unsafe to execute.
  *
- * Valid JSON escapes and literal UTF-8 have the same canonical decoded value.
- * Malformed JSON, duplicate/deep evidence, and unpaired UTF-16 surrogates keep
- * the existing fail-closed path.
+ * Valid JSON escapes and literal UTF-8 have the same canonical decoded value,
+ * including a valid scalar whose hex digits differ from what a caller intended:
+ * runtime syntax validation cannot infer author intent after decoding.
+ * Malformed escape-bearing JSON, duplicate/deep suspicious escape evidence, and
+ * unpaired UTF-16 surrogates keep the fail-closed path.
  */
 export function collectUnsafeUnicodeEscapeEvidence(json: string): UnicodeEscapeEvidence | undefined {
 	const hasUnicodeEscape = json.includes("\\u");

package/src/utils/tool-call-healing.d.ts

@@ -22,10 +22,10 @@ export interface HealedToolCall {
     readonly name: string;
     readonly arguments: string;
     /**
-     * Whether the raw leaked payload spelled a printable non-ASCII character as a
-     * `\uXXXX` escape. Captured BEFORE the normalizing round-trip below, which
-     * decodes escapes into literal characters and would otherwise erase the only
-     * evidence that the text is unverifiable.
+     * Whether the raw leaked payload carried unsafe Unicode argument data.
+     * Captured before the normalizing round-trip below, which would otherwise
+     * erase malformed escape evidence. Valid `\uXXXX` spellings decode
+     * canonically and leave this false.
      */
     readonly escapedNonAsciiArguments: boolean;
     readonly escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;

package/src/utils/tool-call-healing.ts

@@ -40,10 +40,10 @@ export interface HealedToolCall {
 	readonly name: string;
 	readonly arguments: string;
 	/**
-	 * Whether the raw leaked payload spelled a printable non-ASCII character as a
-	 * `\uXXXX` escape. Captured BEFORE the normalizing round-trip below, which
-	 * decodes escapes into literal characters and would otherwise erase the only
-	 * evidence that the text is unverifiable.
+	 * Whether the raw leaked payload carried unsafe Unicode argument data.
+	 * Captured before the normalizing round-trip below, which would otherwise
+	 * erase malformed escape evidence. Valid `\uXXXX` spellings decode
+	 * canonically and leave this false.
 	 */
 	readonly escapedNonAsciiArguments: boolean;
 	readonly escapedUnicodeArgumentEvidence?: UnicodeEscapeEvidence;

package/src/utils/validation.ts

@@ -959,6 +959,8 @@ export function validateToolCall(tools: Tool[], toolCall: ToolCall): ToolCall["a
 }
 
 const RAW_ARGUMENT_REJECTION_MESSAGES: Record<RawArgumentRejectionCode, string> = {
+	"ask-deep-interview-question-body-required":
+		"deep-interview question bodies must contain a specific question, not a placeholder",
 	"ask-intent-review-requires-positive-round":
 		"deepInterview.intent_review is post-Round-0 only and requires a positive round",
 	"ask-intent-contract-requires-non-empty-authority":