@zvada/agent-server 0.3.10 → 0.3.12

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.3.12
+
+- Report a Claude turn whose API call failed as an error. Claude Code ends it
+  as a `success` result flagged `is_error` (a rejected key, an exhausted quota,
+  an overloaded provider), with the failure as its text; it was reported as a
+  completed `end_turn` whose answer quoted the failure. The failure's text now
+  classifies the error (a 401 is `auth`).
+
+## 0.3.11
+
+- Report a Claude turn stopped while a tool runs as `cancelled`. Claude Code
+  ends it with `error_during_execution` and the aborted step's stop reason
+  (`tool_use`), which was reported as an error; an interrupted turn that did
+  not succeed is now a cancellation whatever its stop reason.
+- Confirm a Claude cancel at once while the CLI is still starting: terminate
+  the process instead of waiting for it to acknowledge an interrupt. A slow
+  sandbox startup reported `confirmed: false` after the 2-second interrupt
+  timeout, and a prompt the CLI had not yet dequeued could survive the
+  interrupt and run anyway. The next turn starts a new process.
+
 ## 0.3.10
 
 - Support Codex app-server per-turn stdio and Streamable HTTP MCP configuration

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zvada/agent-server",
-	"version": "0.3.10",
+	"version": "0.3.12",
 	"description": "Harness-agnostic agent execution engine: run Claude Code, Codex (SDK/CLI + app-server), and any ACP agent behind one interface with a normalized event stream, multi-turn sessions, and resume. Root export is the wire contract; /core, /server, /client are the seats.",
 	"license": "MIT",
 	"type": "module",

package/src/core/agents/claude-code/adapter.ts

@@ -97,6 +97,8 @@ type ClaudeMessage =
 			turn_cost_usd?: number | null;
 			stop_reason?: string | null;
 			is_error?: boolean;
+			/** On an `is_error` success, the API failure's text. */
+			result?: string;
 	  };
 
 type BlockKind = "text" | "reasoning" | "tool";
@@ -240,7 +242,7 @@ export class ClaudeCodeTransformer implements EventTransformer<unknown> {
 	private error?: string;
 	private interrupted = false;
 	private execFailure = false;
-	private sawResult = false;
+	private succeeded = false;
 
 	constructor(ctx: { sessionId: string }) {
 		this.ctx = { sessionId: ctx.sessionId, messageId: "" };
@@ -281,17 +283,19 @@ export class ClaudeCodeTransformer implements EventTransformer<unknown> {
 	}
 
 	finish(): TransformResult {
-		// error_during_execution + null stop_reason is cancellation ONLY when the
-		// agent confirmed an interrupt; otherwise it is a real failure (a silent
-		// "cancelled" here is how a bad resume id used to vanish without a trace).
-		// A confirmed interrupt with NO result at all (aborted before the SDK
-		// emitted one) is also a cancellation, not a completed turn.
-		const cancelled = this.interrupted && (this.execFailure || !this.sawResult);
-		const error =
-			this.error ??
-			(this.execFailure && !this.interrupted
-				? "Claude turn failed during execution (error_during_execution — e.g. an invalid resumeSessionId fails this way)"
-				: undefined);
+		// An interrupted turn that did not succeed was cancelled. Claude ends it with
+		// error_during_execution and the stop reason of the step it aborted (null
+		// while streaming, "tool_use" while a tool runs), or with no result when
+		// the process was stopped first. Without an interrupt, error_during_execution
+		// is a real failure (a silent "cancelled" here is how a bad resume id used
+		// to vanish without a trace).
+		const cancelled = this.interrupted && !this.succeeded;
+		const error = cancelled
+			? undefined
+			: (this.error ??
+				(this.execFailure
+					? "Claude turn failed during execution (error_during_execution — e.g. an invalid resumeSessionId fails this way)"
+					: undefined));
 		return {
 			usage: this.usage,
 			...(this.reportedModels.size && { reportedModels: [...this.reportedModels] }),
@@ -503,7 +507,7 @@ export class ClaudeCodeTransformer implements EventTransformer<unknown> {
 	}
 
 	private captureResult(msg: Extract<ClaudeMessage, { type: "result" }>): AdapterEvent[] {
-		this.sawResult = true;
+		this.succeeded = msg.subtype === "success" && !msg.is_error;
 		if (msg.usage) {
 			const creation = msg.usage.cache_creation;
 			this.usage = {
@@ -528,13 +532,19 @@ export class ClaudeCodeTransformer implements EventTransformer<unknown> {
 			if (msg.subtype === "error_during_execution" && msg.stop_reason === null) {
 				// Ambiguous shape: an interrupt AND an execution failure (e.g. a bad
 				// resume id) both surface this way. The agent's `turn_interrupted`
-				// marker (which arrives after this message) disambiguates in finish().
+				// marker (which arrives after this message) disambiguates in finish(),
+				// as it does for an interrupt that aborted a tool (stop reason "tool_use").
 				this.execFailure = true;
 			} else if (msg.subtype === "error_max_turns") {
 				// Hitting the turn budget is a stop condition, not a failure.
 			} else {
 				this.error = `Claude turn ended: ${msg.subtype}`;
 			}
+		} else if (msg.is_error) {
+			// A failed API call (a rejected key, an exhausted quota, an overloaded
+			// provider) ends the turn as a "success" whose text is the error. The
+			// text names the failure, so the runtime classifies it (401 -> auth).
+			this.error = msg.result || "Claude turn ended with an API error";
 		}
 		// Final authoritative gauge: the result knows the context-window size.
 		if (!msg.usage) return [];

package/src/core/agents/claude-code/generator-session.ts

@@ -122,6 +122,8 @@ export class ClaudeGeneratorSession {
 	private readonly failedMcpServers = new Set<string>();
 	private processInvalidated = false;
 	private nativeSessionId: string | null = null;
+	/** Set by the CLI's first message; until then it has begun no turn. */
+	private cliStarted = false;
 	private startupError: unknown;
 	/** SDK cost is cumulative within this query; token usage is already per turn. */
 	private cumulativeCost: number | undefined = 0;
@@ -375,9 +377,17 @@ export class ClaudeGeneratorSession {
 	 * SDK acknowledged it; false when the round-trip timed out or failed — the
 	 * subprocess may still be running its turn and the caller must report that
 	 * honestly instead of assuming a clean cancel.
+	 *
+	 * A session still starting, or whose CLI has sent nothing yet, is terminated
+	 * instead: it has begun no turn, an interrupt would wait out its startup, and
+	 * a prompt the CLI has not dequeued survives an interrupt and runs anyway.
 	 */
 	async interruptTurn(timeoutMs = 2000): Promise<boolean> {
-		if ((this.state !== "busy" && this.state !== "starting") || !this.query) return true;
+		if (this.state === "idle" || this.state === "terminated") return true;
+		if (this.state === "starting" || !this.cliStarted || !this.query) {
+			await this.terminate();
+			return true;
+		}
 		let timer: ReturnType<typeof setTimeout> | undefined;
 		try {
 			await Promise.race([
@@ -422,6 +432,7 @@ export class ClaudeGeneratorSession {
 		if (!this.query) return;
 		try {
 			for await (const event of this.query) {
+				this.cliStarted = true;
 				if (event.type === "system" && event.subtype === "init" && event.session_id) {
 					this.nativeSessionId = event.session_id;
 				}