@gajae-code/ai 0.12.11 → 0.12.13

package/src/utils/tool-choice-capability.ts

@@ -165,7 +165,10 @@ export function resolveToolChoice(
 
 /** Detects provider errors indicating forced tool_choice is unsupported. */
 export function isForcedToolChoiceUnsupportedError(error: unknown, sentForcedToolChoice: boolean): boolean {
-	if (!sentForcedToolChoice || extractHttpStatusFromError(error) !== 400) return false;
+	const status = extractHttpStatusFromError(error);
+	if (!sentForcedToolChoice || status !== 400) {
+		return false;
+	}
 	const message = errorMessage(error);
 	return (
 		// `by <something>` continuations ("not supported by billing") describe a
@@ -179,6 +182,35 @@ export function isForcedToolChoiceUnsupportedError(error: unknown, sentForcedToo
 		/tool[_\s-]?choices?\s+['"`][^'"`\r\n]+['"`]\s+not\s+found\s+in\s+['"`]tools['"`]\s+parameter\b/is.test(message)
 	);
 }
+/**
+ * Detects Codex's statusless SSE rejection for a named function tool choice.
+ * This is intentionally separate from the shared HTTP-400 classifier.
+ */
+export function isCodexStatuslessNamedToolChoiceNotFoundError(
+	error: unknown,
+	forcedToolName: string | undefined,
+	sentToolNames: readonly string[],
+): boolean {
+	if (
+		extractHttpStatusFromError(error) !== undefined ||
+		extractProviderErrorCode(error) !== "invalid_request_error" ||
+		!forcedToolName
+	) {
+		return false;
+	}
+	const match =
+		/^Tool choice '([^']+)' not found in 'tools' parameter\.$/.exec(errorMessage(error)) ??
+		/^Codex error event: Tool choice '([^']+)' not found in 'tools' parameter\. \(code=invalid_request_error\)$/.exec(
+			errorMessage(error),
+		);
+	return match?.[1] === forcedToolName && sentToolNames.includes(forcedToolName);
+}
+
+function extractProviderErrorCode(error: unknown): string | undefined {
+	if (!error || typeof error !== "object") return undefined;
+	const code = (error as { code?: unknown }).code;
+	return typeof code === "string" ? code : undefined;
+}
 
 export type { ToolChoiceCompat, ToolChoiceSupport, ToolChoiceSupportSource } from "../types";
 

package/src/utils/validation.ts

@@ -965,6 +965,11 @@ const RAW_ARGUMENT_REJECTION_MESSAGES: Record<RawArgumentRejectionCode, string>
 		"deepInterview.intent_contract requires non-empty items and confirmation_options",
 	"ask-deep-interview-metadata-requires-deep-interview-gate":
 		"deepInterview metadata cannot be combined with a non-deep-interview workflowGate",
+	"todo-write-unknown-root-key": "todo_write root accepts only an ops array of operation entries",
+	"todo-write-unknown-op-entry-key":
+		"todo_write operation entries accept only op, list, task, phase, items, and text keys",
+	"todo-write-done-drop-requires-target": "todo_write done and drop entries require a task or phase target",
+	"todo-write-unknown-init-entry-key": "todo_write init list entries accept only phase and items keys",
 };
 
 /**

package/src/utils.ts

@@ -199,6 +199,62 @@ function asLowerString(value: unknown): string | undefined {
 	return typeof value === "string" ? value.toLowerCase() : undefined;
 }
 
+/**
+ * Shape-tolerant classifier for the DeepSeek-family reasoning-content replay
+ * rejection: "The `reasoning_content` in the thinking mode must be passed back
+ * to the API." DeepSeek V4 (and reasoning-capable siblings reached through any
+ * OpenAI-compatible proxy) 400 every follow-up turn once a prior assistant turn
+ * carried reasoning the proxy stripped to an empty `encrypted_content` /
+ * `reasoning_content`. Resending the identical history re-triggers it, so naive
+ * session auto-retry just burns the budget — it needs the same bounded
+ * repair-and-resend contract as the `invalid_prompt` poisoned-history breaker.
+ *
+ * Accepts a raw provider error, an assistant message, or any object carrying an
+ * `errorMessage` field (the agent-loop circuit breaker keys on this).
+ */
+export function isReasoningContentReplayError(input: unknown): boolean {
+	if (!input) return false;
+	const message =
+		typeof input === "string"
+			? input
+			: input && typeof input === "object"
+				? ((input as { errorMessage?: unknown; message?: unknown }).errorMessage ??
+					(input as { message?: unknown }).message)
+				: undefined;
+	return typeof message === "string" && REASONING_CONTENT_REPLAY_MESSAGE_RE.test(message);
+}
+
+const REASONING_CONTENT_REPLAY_MESSAGE_RE =
+	/reasoning_content[\s\S]*must be passed back to the API|reasoning content[\s\S]*must be passed back to the API/i;
+
+/**
+ * Remove Responses-API `reasoning` items whose `encrypted_content` is missing or
+ * empty from an outgoing history payload. DeepSeek rejects replay of reasoning
+ * whose encrypted blob a proxy stripped to `""`; dropping those items lets the
+ * model re-reason on the next turn instead of re-triggering a deterministic 400.
+ * Non-reasoning items (text, function_call, function_call_output, ...) are kept
+ * verbatim so tool-use pairing and message order are preserved. Returns whether
+ * any item was actually removed — the circuit breaker uses this to decide
+ * between a single repaired resend (removed) and immediate fail-fast (unchanged).
+ */
+export function stripUnusableReasoningItems(items: Array<Record<string, unknown>>): {
+	result: Array<Record<string, unknown>>;
+	removed: number;
+} {
+	let removed = 0;
+	const result: Array<Record<string, unknown>> = [];
+	for (const item of items) {
+		if (item?.type === "reasoning") {
+			const encrypted = item.encrypted_content;
+			if (encrypted === undefined || encrypted === null || encrypted === "") {
+				removed++;
+				continue;
+			}
+		}
+		result.push(item);
+	}
+	return { result, removed };
+}
 /**
  * Neutralize leaked reserved control tokens across every string in an outgoing
  * Responses `input` array. This is the request-boundary complement to the