@gajae-code/coding-agent 0.16.7 → 0.17.1

package/src/sdk/host/session-runtime.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, spyOn, test } from "bun:test";
+import { describe, expect, setDefaultTimeout, spyOn, test } from "bun:test";
 import { createHash } from "node:crypto";
 import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import * as os from "node:os";
@@ -32,6 +32,15 @@ import { createSdkCapabilities, createSdkSurfacePolicy } from "./surface-policy"
 import type { SdkFrame } from "./types";
 import { SdkTransportLifecycleError } from "./websocket-transport";
 
+setDefaultTimeout(30_000);
+
+test("runtime capabilities preserve explicit primary control surface", () => {
+	const policy = createSdkSurfacePolicy({ bindings: [], workflowGateAvailable: false });
+	expect(createSdkCapabilities(policy)).toMatchObject({ primaryControlSurface: "sdk" });
+	expect(createSdkCapabilities(policy, false, "sdk")).toMatchObject({ primaryControlSurface: "sdk" });
+	expect(createSdkCapabilities(policy, false, "cli")).toMatchObject({ primaryControlSurface: "cli" });
+});
+
 function memoryTransport(): SessionSdkTransport & {
 	feed(connectionId: string, frame: SdkFrame): void;
 	readonly sent: SdkFrame[];
@@ -429,7 +438,7 @@ test("SDK-only finalizeOutcome keeps legacy recordError positional compatibility
 	});
 	expect(compatReconciliation.lookup("prompt", { clientRef: "finalize-compat-ref" })).toMatchObject({
 		status: "failed",
-		error: { code: "legacy_error", message: "legacy message" },
+		error: { code: "legacy_error", message: "Prompt submission failed." },
 	});
 	// The isCurrent callback shape still fences a stale finalize to a no-op.
 	const second = createInvocationReconciliation();
@@ -4040,7 +4049,16 @@ describe("post-acceptance invocation terminalization", () => {
 			});
 			expect(terminal).toMatchObject({
 				status: "failed",
-				error: { code, message: "Prompt submission failed." },
+				error: { code, message: "Provider failure after execution started." },
+				outcome: {
+					kind: "failed",
+					code: "prompt_failed",
+					message: "Provider failure after execution started.",
+					provenance: "agent_failed",
+					phase: "post_start",
+					category: "provider_rejected",
+					providerCode: code,
+				},
 				terminalAt: expect.any(Number),
 			});
 			const stable = await harness.query("turn.result", { kind: "prompt", ...failedIds });
@@ -4497,10 +4515,8 @@ describe("post-acceptance invocation terminalization", () => {
 					messages: [{ role: "assistant", stopReason: "error", errorStatus: status }],
 				});
 				await entered.promise;
-				const startedAt = Date.now();
 				const lifecycleChange = harness[operation](`${operation}-stall-successor`);
 				await lifecycleChange;
-				expect(Date.now() - startedAt).toBeLessThan(1_500);
 				expect(timeoutWarnings).toBe(1);
 				release.resolve();
 				firstInflight.resolve();
@@ -4662,7 +4678,16 @@ describe("post-acceptance invocation terminalization", () => {
 			// the failure reason survives as the safe-token code.
 			expect(await settledStatus(harness, "turn.prompt_status", { commandId, turnId })).toMatchObject({
 				status: "failed",
-				error: { code: "upstream_stream_interrupted", message: "Prompt submission failed." },
+				error: { code: "upstream_stream_interrupted", message: "Provider failure after execution started." },
+				outcome: {
+					kind: "failed",
+					code: "prompt_failed",
+					message: "Provider failure after execution started.",
+					provenance: "agent_failed",
+					phase: "post_start",
+					category: "provider_transport",
+					providerCode: "upstream_stream_interrupted",
+				},
 			});
 			await harness.stop();
 		} finally {
@@ -4955,7 +4980,7 @@ describe("post-acceptance invocation terminalization", () => {
 		const cases = [
 			{ name: "short", agent: "SDK_OK", expected: "SDK_OK", bytes: 6, truncated: false },
 			{ name: "max", agent: "x".repeat(16_384), expected: "x".repeat(16_384), bytes: 16_384, truncated: false },
-			{ name: "blank", agent: " ", expected: undefined, bytes: 0, truncated: false },
+			{ name: "blank", agent: " ", expected: undefined, bytes: 0, truncated: false, status: "failed" },
 			{
 				name: "overflow",
 				agent: `${"😀".repeat(4_096)}tail`,
@@ -4982,7 +5007,7 @@ describe("post-acceptance invocation terminalization", () => {
 					turnId: accepted.result?.turnId,
 				});
 				if (testCase.expected === undefined) {
-					expect(result).toMatchObject({ status: "failed" });
+					expect(result).toMatchObject({ status: testCase.status });
 					expect((result as Record<string, unknown>).content).toBeUndefined();
 				} else {
 					expect(result).toMatchObject({
@@ -5000,6 +5025,302 @@ describe("post-acceptance invocation terminalization", () => {
 			}
 		}
 	});
+	test("fails closed when an assistant turn has only empty reasoning and zero token usage", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminal-zero-token-empty-"));
+		try {
+			const harness = await invocationHarness("terminal-zero-token-empty", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await Promise.withResolvers<void>().promise;
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				messages: [
+					{
+						role: "assistant",
+						content: [{ type: "thinking", thinking: "" }],
+						usage: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							totalTokens: 0,
+							cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+						},
+						stopReason: "stop",
+					},
+				],
+			});
+			const result = await settledStatus(harness, "turn.result", {
+				kind: "prompt",
+				commandId: accepted.result?.commandId,
+				turnId: accepted.result?.turnId,
+			});
+			expect(result).toMatchObject({
+				status: "failed",
+				error: { code: "prompt_failed", message: "Agent run failed after execution started." },
+				outcome: {
+					kind: "failed",
+					code: "prompt_failed",
+					message: "Agent run failed after execution started.",
+					provenance: "agent_failed",
+					phase: "post_start",
+					category: "agent_runtime",
+				},
+			});
+			const successor = await harness.control("turn.prompt", { text: "successor" });
+			expect(successor).toMatchObject({ ok: true, result: { accepted: true } });
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", { messages: [{ role: "assistant", content: "completed" }] });
+			expect(
+				await settledStatus(harness, "turn.result", {
+					kind: "prompt",
+					commandId: successor.result?.commandId,
+					turnId: successor.result?.turnId,
+				}),
+			).toMatchObject({ status: "terminal_ok" });
+			await harness.stop();
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+	test("preserves valid textless terminal evidence", async () => {
+		const cases = [
+			{
+				name: "reasoning-only",
+				content: [{ type: "thinking", thinking: "private reasoning" }],
+				usage: { totalTokens: 0 },
+			},
+			{
+				name: "redacted-reasoning-only",
+				content: [{ type: "redactedThinking", data: "encrypted reasoning" }],
+				usage: { totalTokens: 0 },
+			},
+			{
+				name: "tool-only",
+				content: [{ type: "toolCall", id: "call-1", name: "read", arguments: {} }],
+				usage: { totalTokens: 0 },
+			},
+			{
+				name: "positive-token-usage",
+				content: [{ type: "thinking", thinking: "" }],
+				usage: { totalTokens: 1 },
+			},
+		] as const;
+		for (const testCase of cases) {
+			const cwd = await mkdtemp(path.join(os.tmpdir(), `gjc-terminal-valid-${testCase.name}-`));
+			try {
+				const harness = await invocationHarness(`terminal-valid-${testCase.name}`, cwd, {
+					sendUserMessage: async (_content, options) => {
+						await options?.onPreflightAcceptCommit?.();
+						await Promise.withResolvers<void>().promise;
+					},
+				});
+				const accepted = await harness.control("turn.prompt", { text: "hello" });
+				await harness.emit("agent_start");
+				await harness.emit("agent_end", {
+					messages: [
+						{
+							role: "assistant",
+							content: testCase.content,
+							...(testCase.usage === undefined ? {} : { usage: testCase.usage }),
+						},
+					],
+				});
+				expect(
+					await settledStatus(harness, "turn.result", {
+						kind: "prompt",
+						commandId: accepted.result?.commandId,
+						turnId: accepted.result?.turnId,
+					}),
+				).toMatchObject({ status: "terminal_ok" });
+				await harness.stop();
+			} finally {
+				await rm(cwd, { recursive: true, force: true });
+			}
+		}
+	});
+	test("preserves earlier complete tool activity before a trailing empty assistant", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminal-earlier-tool-activity-"));
+		try {
+			const harness = await invocationHarness("terminal-earlier-tool-activity", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await Promise.withResolvers<void>().promise;
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				messages: [
+					{
+						role: "assistant",
+						content: [{ type: "toolCall", id: "call-1", name: "read", arguments: { path: "file.txt" } }],
+						usage: { totalTokens: 1 },
+					},
+					{
+						role: "toolResult",
+						toolCallId: "call-1",
+						toolName: "read",
+						content: [{ type: "text", text: "contents" }],
+					},
+					{
+						role: "assistant",
+						content: [{ type: "thinking", thinking: "" }],
+						usage: { totalTokens: 0 },
+					},
+				],
+			});
+			expect(
+				await settledStatus(harness, "turn.result", {
+					kind: "prompt",
+					commandId: accepted.result?.commandId,
+					turnId: accepted.result?.turnId,
+				}),
+			).toMatchObject({ status: "terminal_ok" });
+			await harness.stop();
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+	test("fails closed without independent terminal evidence", async () => {
+		const cases = [
+			{ name: "usage-omitted", content: [{ type: "thinking", thinking: "" }], omitUsage: true },
+			{ name: "usage-null", content: [{ type: "thinking", thinking: "" }], usage: null },
+			{ name: "primitive-usage", content: [{ type: "thinking", thinking: "" }], usage: "bad" },
+			{ name: "array-usage", content: [{ type: "thinking", thinking: "" }], usage: [] },
+			{ name: "missing-total-tokens", content: [{ type: "thinking", thinking: "" }], usage: { input: 0 } },
+			{
+				name: "undefined-total-tokens",
+				content: [{ type: "thinking", thinking: "" }],
+				usage: { totalTokens: undefined },
+			},
+			{ name: "negative-total-tokens", content: [{ type: "thinking", thinking: "" }], usage: { totalTokens: -1 } },
+			{
+				name: "nan-total-tokens",
+				content: [{ type: "thinking", thinking: "" }],
+				usage: { totalTokens: Number.NaN },
+			},
+			{
+				name: "infinite-total-tokens",
+				content: [{ type: "thinking", thinking: "" }],
+				usage: { totalTokens: Number.POSITIVE_INFINITY },
+			},
+			{
+				name: "incomplete-tool-call",
+				content: [
+					{
+						type: "toolCall",
+						id: "call-1",
+						name: "read",
+						arguments: {},
+						incompleteArguments: true,
+						incompleteArgumentsReason: "truncated",
+					},
+				],
+				usage: { totalTokens: 0 },
+			},
+			{
+				name: "malformed-tool-arguments",
+				content: [{ type: "toolCall", id: "call-1", name: "read", arguments: null }],
+				usage: { totalTokens: 0 },
+			},
+			{
+				name: "orphaned-incomplete-reason",
+				content: [
+					{
+						type: "toolCall",
+						id: "call-1",
+						name: "read",
+						arguments: {},
+						incompleteArgumentsReason: "malformed",
+					},
+				],
+				usage: { totalTokens: 0 },
+			},
+		] as const;
+		for (const testCase of cases) {
+			const cwd = await mkdtemp(path.join(os.tmpdir(), `gjc-terminal-malformed-${testCase.name}-`));
+			try {
+				const harness = await invocationHarness(`terminal-malformed-${testCase.name}`, cwd, {
+					sendUserMessage: async (_content, options) => {
+						await options?.onPreflightAcceptCommit?.();
+						await Promise.withResolvers<void>().promise;
+					},
+				});
+				const accepted = await harness.control("turn.prompt", { text: "hello" });
+				await harness.emit("agent_start");
+				await harness.emit("agent_end", {
+					messages: [
+						{
+							role: "assistant",
+							content: testCase.content,
+							...("omitUsage" in testCase ? {} : { usage: testCase.usage }),
+						},
+					],
+				});
+				expect(
+					await settledStatus(harness, "turn.result", {
+						kind: "prompt",
+						commandId: accepted.result?.commandId,
+						turnId: accepted.result?.turnId,
+					}),
+				).toMatchObject({
+					status: "failed",
+					error: { code: "prompt_failed", message: "Agent run failed after execution started." },
+					outcome: {
+						kind: "failed",
+						code: "prompt_failed",
+						message: "Agent run failed after execution started.",
+						provenance: "agent_failed",
+						phase: "post_start",
+						category: "agent_runtime",
+					},
+				});
+				await harness.stop();
+			} finally {
+				await rm(cwd, { recursive: true, force: true });
+			}
+		}
+	});
+	test("preserves explicit cancellation for an empty zero-token turn", async () => {
+		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminal-empty-cancelled-"));
+		try {
+			const harness = await invocationHarness("terminal-empty-cancelled", cwd, {
+				sendUserMessage: async (_content, options) => {
+					await options?.onPreflightAcceptCommit?.();
+					await Promise.withResolvers<void>().promise;
+				},
+			});
+			const accepted = await harness.control("turn.prompt", { text: "hello" });
+			await harness.emit("agent_start");
+			await harness.emit("agent_end", {
+				stopReason: "cancelled",
+				messages: [
+					{
+						role: "assistant",
+						content: [{ type: "thinking", thinking: "" }],
+						usage: { totalTokens: 0 },
+					},
+				],
+			});
+			expect(
+				await settledStatus(harness, "turn.result", {
+					kind: "prompt",
+					commandId: accepted.result?.commandId,
+					turnId: accepted.result?.turnId,
+				}),
+			).toMatchObject({
+				status: "terminal_ok",
+				outcome: { kind: "stopped", reason: "cancelled", provenance: "client_cancel" },
+			});
+			await harness.stop();
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
 	test("does not reuse a previous branch assistant for a new textless prompt", async () => {
 		const cwd = await mkdtemp(path.join(os.tmpdir(), "gjc-terminal-order-previous-assistant-"));
 		try {