@gajae-code/agent-core 0.12.11 → 0.12.13

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.12.13] - 2026-08-06
+
+### Fixed
+
+- An aborted run whose tool ignores its `AbortSignal` now terminates on its own (#3894). `Promise.allSettled` waited on the unresolved call forever, so the turn only ended when the session's force-abort budget expired; the loop now emits a synthetic aborted result for the outstanding calls and `waitForIdle` settles immediately. Session dispose consequently reaches idle through the cooperative path instead of force-invalidating the run.
+
+## [0.12.12] - 2026-08-05
+
+### Fixed
+
+- DeepSeek-family reasoning-content replay 400s are now retryable via a bounded, strip-only circuit breaker. When a proxy strips the encrypted reasoning blob to an empty `encrypted_content`, DeepSeek rejects every follow-up turn with "The `reasoning_content` in the thinking mode must be passed back to the API." Resending the identical history re-triggers this deterministic 400, so the agent loop now strips the unusable `reasoning` items from the Responses history payload in place and resends exactly once (mirroring the `invalid_prompt` poisoned-history breaker). Non-reasoning items are preserved; fail-fast when nothing can be stripped. Budget = one repaired resend.
+
 ## [0.12.11] - 2026-08-03
 
 ## [0.12.10] - 2026-08-03

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/agent-core",
-	"version": "0.12.11",
+	"version": "0.12.13",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -32,9 +32,9 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/ai": "0.12.11",
-		"@gajae-code/natives": "0.12.11",
-		"@gajae-code/utils": "0.12.11",
+		"@gajae-code/ai": "0.12.13",
+		"@gajae-code/natives": "0.12.13",
+		"@gajae-code/utils": "0.12.13",
 		"@opentelemetry/api": "^1.9.0"
 	},
 	"devDependencies": {

package/src/agent-loop.ts

@@ -24,7 +24,12 @@ import {
 	COMPOSER_BASH_POLICY_RECOVERY_PROMPT,
 	isCurrentComposerBashPolicyBlockedError,
 } from "@gajae-code/ai/providers/composer-discipline";
-import { isInvalidPromptError, neutralizeReservedControlTokens } from "@gajae-code/ai/utils";
+import {
+	isInvalidPromptError,
+	isReasoningContentReplayError,
+	neutralizeReservedControlTokens,
+	stripUnusableReasoningItems,
+} from "@gajae-code/ai/utils";
 import { sanitizeText } from "@gajae-code/utils";
 import type { AttemptScope } from "./attempt-scope";
 import {
@@ -202,6 +207,31 @@ function repairInvalidPromptHistory(messages: AgentMessage[]): boolean {
 	}
 	return changed;
 }
+/**
+ * Strip Responses-API `reasoning` items whose `encrypted_content` a proxy
+ * emptied, in-place across the outgoing history's `providerPayload`. DeepSeek in
+ * thinking mode rejects replay of reasoning whose encrypted blob was stripped,
+ * so dropping those items lets the model re-reason instead of re-triggering a
+ * deterministic 400 ("reasoning_content ... must be passed back to the API").
+ * Only the opaque Responses history payload is mutated; durable message content
+ * and ordering 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).
+ */
+function repairReasoningContentReplayHistory(messages: AgentMessage[]): boolean {
+	let removed = 0;
+	for (const message of messages) {
+		const payload = (message as { providerPayload?: { type?: string; items?: Array<Record<string, unknown>> } })
+			.providerPayload;
+		if (payload?.type !== "openaiResponsesHistory" || !Array.isArray(payload.items)) continue;
+		const { result, removed: count } = stripUnusableReasoningItems(payload.items);
+		if (count > 0) {
+			payload.items = result;
+			removed += count;
+		}
+	}
+	return removed > 0;
+}
 
 function managedFailureOutcome(message: AssistantMessage, scope?: AttemptScope): ManagedAttemptOutcome {
 	return {
@@ -1418,6 +1448,9 @@ async function runLoopBody(
 	// Fires at most one repaired resend per run for the poisoned-history
 	// `invalid_prompt` circuit breaker below.
 	let invalidPromptRepairAttempted = false;
+	// Fires at most one repaired resend per run for the reasoning-content replay
+	// breaker below (DeepSeek "reasoning_content ... must be passed back").
+	let reasoningContentRepairAttempted = false;
 	let previousMalformedToolSignatures = new Set<string>();
 	type SyntheticRecoveryKind = "malformed-tool-call" | "composer-bash-policy" | "provider";
 	let pendingRecovery:
@@ -1680,6 +1713,40 @@ async function runLoopBody(
 					continue;
 				}
 			}
+			// Session-level reasoning-content replay circuit breaker (bounded,
+			// strip-only). DeepSeek V4 (and reasoning-capable siblings on any
+			// OpenAI-compatible proxy) reject every follow-up turn with
+			// "reasoning_content ... must be passed back to the API" once a prior
+			// assistant turn carried reasoning the proxy stripped to an empty
+			// `encrypted_content`. Resending the identical history re-triggers the
+			// deterministic 400, so naive auto-retry would loop. On the first such
+			// rejection of this run, strip the unusable `reasoning` items from the
+			// Responses history payload IN PLACE (never dropping text, tool-call, or
+			// tool-output items). If that removed anything, resend exactly once so
+			// the model re-reasons; if nothing could be stripped, fall through to
+			// terminal handling and fail fast. Budget = one repaired resend.
+			if (
+				!config.fallbackManaged &&
+				message.stopReason === "error" &&
+				!reasoningContentRepairAttempted &&
+				isReasoningContentReplayError(message)
+			) {
+				reasoningContentRepairAttempted = true;
+				// The rejected turn was already committed to the context by the
+				// streaming path. Repair (and resend) only the history that
+				// preceded it: replaying an errored assistant turn re-triggers the
+				// rejection and leaves a second assistant tail behind.
+				const rejectedIndex = currentContext.messages.length - 1;
+				const rejectedCommitted =
+					rejectedIndex >= 0 && currentContext.messages[rejectedIndex]?.role === "assistant";
+				const retained = rejectedCommitted
+					? currentContext.messages.slice(0, rejectedIndex)
+					: currentContext.messages;
+				if (repairReasoningContentReplayHistory(retained)) {
+					if (rejectedCommitted) currentContext.messages.splice(rejectedIndex, 1);
+					continue;
+				}
+			}
 
 			const overflow = managedContextOverflow(message, config);
 			if (config.fallbackManaged && overflow) {
@@ -2828,7 +2895,26 @@ async function executeToolCalls(
 		}
 	}
 
-	await Promise.allSettled(tasks);
+	const allTasks = Promise.allSettled(tasks);
+	if (!signal) {
+		await allTasks;
+	} else {
+		const abortPromise = Promise.withResolvers<boolean>();
+		const onAbort = () => abortPromise.resolve(true);
+		signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			const aborted = signal.aborted || (await Promise.race([allTasks.then(() => false), abortPromise.promise]));
+			if (aborted) {
+				for (const record of records) {
+					if (record.toolResultMessage) continue;
+					record.skipped = true;
+					emitToolResult(record, createAbortedToolExecutionResult(), true);
+				}
+			}
+		} finally {
+			signal.removeEventListener("abort", onAbort);
+		}
+	}
 
 	for (const record of records) {
 		if (!record.toolResultMessage) {
@@ -2903,3 +2989,9 @@ function createSkippedToolResult(): AgentToolResult<any> {
 		details: {},
 	};
 }
+function createAbortedToolExecutionResult(): AgentToolResult<any> {
+	return {
+		content: [{ type: "text", text: "Tool execution was aborted." }],
+		details: {},
+	};
+}