@gajae-code/agent-core 0.14.2 → 0.15.0

package/src/agent.ts

@@ -19,13 +19,14 @@ import {
 	type ThinkingBudgets,
 	type ToolChoice,
 	type ToolResultMessage,
+	type UserMessage,
 } from "@gajae-code/ai";
 import {
 	CURSOR_COMPOSER_BASH_POLICY_RECOVERY_PROMPT,
 	isCurrentComposerBashPolicyBlockedError,
 } from "@gajae-code/ai/providers/composer-discipline";
 import { extractHttpStatusFromError } from "@gajae-code/utils";
-import { agentLoop, agentLoopContinue } from "./agent-loop";
+import { agentLoop, agentLoopContinue, managedLocalErrorDiagnostic } from "./agent-loop";
 import type { AppendOnlyContextManager } from "./append-only-context";
 import type { AttemptRunHandle, AttemptScope } from "./attempt-scope";
 import { createAttemptScopeAuthority } from "./attempt-scope";
@@ -318,6 +319,8 @@ export interface AgentOptions {
 }
 
 export interface AgentPromptOptions {
+	/** One-shot transient recovery instruction sent only to the provider for the next assistant request; never committed to durable history. */
+	transientRecoveryMessage?: UserMessage;
 	toolChoice?: ToolChoice;
 	/** Disable transport replay; fallback accounting is owned by the caller. */
 	fallbackManaged?: boolean;
@@ -1867,6 +1870,7 @@ export class Agent {
 						return (await this.#maintainContext?.(context, lifecycle)) ?? "not-needed";
 					}
 				: undefined,
+			transientRecoveryMessage: options?.transientRecoveryMessage,
 			telemetry: this.#telemetry,
 		};
 
@@ -2005,9 +2009,12 @@ export class Agent {
 				stopReason: abortController.signal.aborted ? "aborted" : "error",
 				errorMessage: err?.message || String(err),
 				errorStatus: extractHttpStatusFromError({ status: err?.errorStatus }) ?? extractHttpStatusFromError(err),
-				...(err?.errorKind === "local_snapshot_failure" || err?.errorKind === "local_buffer_overflow"
-					? { errorKind: err.errorKind as "local_snapshot_failure" | "local_buffer_overflow" }
-					: {}),
+				// Local-diagnostic authority (`errorKind` + structured
+				// `bufferOverflow`) comes from ONE identity check: a foreign error
+				// that self-declares a local kind gets neither field, so the parent
+				// receipt never misattributes a provider/stream failure to the local
+				// staging machinery (#4618).
+				...(managedLocalErrorDiagnostic(err) ?? {}),
 				timestamp: Date.now(),
 			} as AgentMessage;
 

package/src/prompts/escaped-nonascii-recovery.md

@@ -0,0 +1,3 @@
+Your previous response was discarded before execution: its tool-call arguments spelled non-ASCII text as `\uXXXX` escape sequences instead of literal UTF-8 characters. Escaped text cannot be verified — a single mistyped hex digit silently becomes a different, equally valid character — so such calls are never executed.
+
+Re-issue the same tool call now, writing every non-ASCII character literally (for example 한글, 日本語, émoji — never `\uXXXX`). Do not change the intent or content of the call; only the spelling of the text.

package/src/types.ts

@@ -186,6 +186,14 @@ export type ManagedAttemptOutcome =
 			type: "escaped_arguments_discarded";
 			/** The defective assistant turn; already removed from usable history by the loop. */
 			message: AssistantMessage;
+			/**
+			 * True when this discarded attempt had no transient steering instruction
+			 * attached yet. A managed retry continuation should carry the escaped
+			 * non-ASCII recovery instruction exactly once, so a deterministic
+			 * escaper has a reason to change its spelling; the instruction never
+			 * lands in durable history. Absent/false means steering already ran.
+			 */
+			steeringPending?: boolean;
 			scope?: AttemptScope;
 	  }
 	| { type: "context_overflow_discarded"; message: AssistantMessage; scope?: AttemptScope }
@@ -346,10 +354,17 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
 	/**
 	 * Invoked with the follow-up messages the loop dequeues for the next turn
 	 * (right after {@link getFollowUpMessages}). The consumer may use this to
-	 * attach per-turn state (e.g. a fresh owned-completion lineage) at actual
+	 * attach per-turn state (e.g., a fresh owned-completion lineage) at actual
 	 * resume admission rather than when the message was merely queued.
 	 */
 	onFollowUpConsumed?: (messages: AgentMessage[]) => void;
+	/**
+	 * One-shot transient recovery instruction attached to the first assistant
+	 * request of this loop invocation. Sent only to the provider (never committed
+	 * to durable agent message history) so a caller-owned retry of a discarded
+	 * attempt can name the defect it is retrying around.
+	 */
+	transientRecoveryMessage?: UserMessage;
 	/**
 	 * Supplies one bounded synthetic recovery instruction before the loop would
 	 * otherwise yield. Unlike a follow-up, it is sent only to the provider and