@gajae-code/coding-agent 0.16.3 → 0.16.6

package/src/sdk/protocol/operation-inventory.generated.json

@@ -2841,6 +2841,50 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:awaitDisposeCompletion",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only disposal completion seam, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:setDisposeTimeoutForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only disposal timeout seam, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:trackPostPromptTaskForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only post-prompt task seam, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:requestWorkerIntegrationForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only worker integration seam, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:closeWriterStrict",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -2885,6 +2929,28 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:runWithPromptAdmissionForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only prompt admission seam, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
+	{
+		"sourceId": "agent_session:awaitCoordinatorRuntimeStatePersistenceForTests",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "test-only coordinator persistence drain barrier, not a user-facing SDK control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:queueCoordinatorRuntimeStatePersistForTests",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -3912,6 +3978,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:reloadSkills",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal marketplace lifecycle refresh for the session skill catalog; not an independent SDK ingress operation",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:retireWorkspaceTreeForRescope",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

package/src/sdk/router/session-router.ts

@@ -2,6 +2,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { logger, resolveEquivalentPath } from "@gajae-code/utils";
+import { matchesIndexedEndpointFile } from "../broker/endpoint-authority";
 import {
 	canonicalSessionCwd,
 	SessionIndex as DefaultSessionIndex,
@@ -11,7 +12,13 @@ import {
 	type SessionIndex,
 } from "../broker/session-index";
 import { cancellableSleep, lifecycleRequestTimeoutMs } from "../broker/startup-budget";
-import { SdkClient, SdkClientError, type SdkDispatchContext, type SdkDispatchHandler } from "../client/client";
+import {
+	SdkClient,
+	SdkClientError,
+	type SdkDispatchContext,
+	type SdkDispatchHandler,
+	SdkPreparedDispatchError,
+} from "../client/client";
 import {
 	endpointDirectory,
 	readSdkBrokerDiscovery,
@@ -27,6 +34,7 @@ import {
 import { ACP_SESSION_RECONNECT, SESSION_REQUEST_TIMEOUT_MS } from "../session-reconnect";
 
 export interface SessionEndpointIdentity {
+	readonly dev: bigint;
 	readonly mtimeMs: number;
 	readonly mtimeNs: bigint;
 	readonly ctimeNs: bigint;
@@ -56,6 +64,7 @@ export function sessionAttachmentAuthorityId(input: {
 		.digest("hex");
 	const endpointIdentity = input.endpointIdentity
 		? {
+				dev: input.endpointIdentity.dev.toString(),
 				mtimeMs: input.endpointIdentity.mtimeMs,
 				mtimeNs: input.endpointIdentity.mtimeNs.toString(),
 				ctimeNs: input.endpointIdentity.ctimeNs.toString(),
@@ -86,7 +95,13 @@ export interface SessionAttachment {
 	readonly connectionId?: string;
 	readonly generation: number;
 	isCurrent(): boolean;
-	send(frame: Record<string, unknown>): unknown;
+	send(
+		frame: Record<string, unknown>,
+		options?: {
+			beforeDispatch?: () => void;
+			dispatchFence?: (dispatch: () => Promise<void>) => Promise<void>;
+		},
+	): unknown;
 	/**
 	 * Idempotent provider-lease heartbeat send that skips the pre-send authority
 	 * reconcile (#4689).
@@ -179,6 +194,7 @@ export interface SessionRouterClient {
 		frame: Record<string, unknown>,
 		options?: {
 			timeoutMs?: number;
+			connectedOnly?: boolean;
 			/** Synchronous pre-send observer; a throw aborts the dispatch before the wire. */
 			beforeDispatch?: (context: SdkDispatchContext) => void;
 			/** Synchronous post-send boundary observer for transport-close-aware consumers. */
@@ -456,6 +472,7 @@ async function lstatEndpoint(file: string): Promise<SessionEndpointIdentity | un
 	)
 		return undefined;
 	return {
+		dev: identity.dev,
 		mtimeMs: stat.mtimeMs,
 		mtimeNs: identity.mtimeNs,
 		ctimeNs: identity.ctimeNs,
@@ -470,6 +487,7 @@ function warningAffectsSession(warning: string, sessionId: string): boolean {
 
 function sameEndpointIdentity(expected: SessionEndpointIdentity, current: SessionEndpointIdentity): boolean {
 	return (
+		expected.dev === current.dev &&
 		expected.mtimeMs === current.mtimeMs &&
 		expected.mtimeNs === current.mtimeNs &&
 		expected.ctimeNs === current.ctimeNs &&
@@ -909,6 +927,7 @@ export class SessionRouter {
 			timeoutMs?: number;
 			beforeDispatch?: (context: SdkDispatchContext) => void;
 			onDispatch?: SdkDispatchHandler;
+			dispatchFence?: (dispatch: () => Promise<Record<string, unknown>>) => Promise<Record<string, unknown>>;
 		},
 	): Promise<Record<string, unknown>> {
 		const matchesExpectedAuthority = (attachment: SessionAttachment): boolean =>
@@ -946,31 +965,34 @@ export class SessionRouter {
 		// token: the wire frame alone carries credentials, and the observer
 		// context is a deep-frozen, token-redacted copy (#4640 review).
 		const wireFrame = this.#prepareFrame(attached, frame);
-		const { beforeDispatch, onDispatch, ...requestOptions } = options ?? {};
-		const response = await attached.client.request(wireFrame, {
-			...requestOptions,
-			timeoutMs: requestOptions.timeoutMs ?? SESSION_REQUEST_TIMEOUT_MS,
-			...(beforeDispatch
-				? {
-						beforeDispatch: (context: SdkDispatchContext) => {
-							return beforeDispatch({
-								...context,
-								frame: redactDispatchFrame(context.frame),
-							});
-						},
-					}
-				: {}),
-			...(onDispatch
-				? {
-						onDispatch: (context: SdkDispatchContext) => {
-							return onDispatch({
-								...context,
-								frame: redactDispatchFrame(context.frame),
-							});
-						},
-					}
-				: {}),
-		});
+		const { beforeDispatch, onDispatch, dispatchFence, ...requestOptions } = options ?? {};
+		try {
+			await attached.client.connect?.();
+		} catch (error) {
+			if (error instanceof SdkClientError) throw new SdkPreparedDispatchError(error);
+			throw error;
+		}
+		if (!this.#attachmentPublished(attached))
+			throw new SessionRouterError("pre_send", "SDK session attachment changed during transport preparation.");
+		const dispatch = () =>
+			attached.client.request(wireFrame, {
+				...requestOptions,
+				connectedOnly: true,
+				timeoutMs: requestOptions.timeoutMs ?? SESSION_REQUEST_TIMEOUT_MS,
+				...(beforeDispatch
+					? {
+							beforeDispatch: (context: SdkDispatchContext) =>
+								beforeDispatch({ ...context, frame: redactDispatchFrame(context.frame) }),
+						}
+					: {}),
+				...(onDispatch
+					? {
+							onDispatch: (context: SdkDispatchContext) =>
+								onDispatch({ ...context, frame: redactDispatchFrame(context.frame) }),
+						}
+					: {}),
+			});
+		const response = await (dispatchFence ? dispatchFence(dispatch) : dispatch());
 		const settled = this.#sessions.get(sessionId);
 		if (
 			!settled ||
@@ -1141,7 +1163,12 @@ export class SessionRouter {
 	}
 
 	/** Lists saved sessions through Router-owned Broker discovery without exposing credentials or mutation authority. */
-	async listBrokerSessions(input: Record<string, unknown>, idempotencyKey: string): Promise<Record<string, unknown>> {
+	async listBrokerSessions(
+		input: Record<string, unknown>,
+		idempotencyKey: string,
+		options?: { beforeDispatch?: (context: SdkDispatchContext) => void },
+		dispatchFence?: (dispatch: () => Promise<Record<string, unknown>>) => Promise<Record<string, unknown>>,
+	): Promise<Record<string, unknown>> {
 		const operation = "session.list";
 		const discovery = await readSdkBrokerDiscovery(this.#agentDir);
 		if (!discovery) throw new SessionRouterError("pre_send", "SDK broker discovery is unavailable.");
@@ -1155,10 +1182,18 @@ export class SessionRouter {
 		}
 		try {
 			const timeoutMs = lifecycleRequestTimeoutMs(operation, input);
-			return await client.request(
-				{ type: "broker_request", operation, input, idempotencyKey },
-				timeoutMs === undefined ? undefined : { timeoutMs },
-			);
+			try {
+				await client.connect?.();
+			} catch (error) {
+				if (error instanceof SdkClientError) throw new SdkPreparedDispatchError(error);
+				throw error;
+			}
+			const dispatch = () =>
+				client.request(
+					{ type: "broker_request", operation, input, idempotencyKey },
+					{ ...(timeoutMs === undefined ? {} : { timeoutMs }), ...options, connectedOnly: true },
+				);
+			return await (dispatchFence ? dispatchFence(dispatch) : dispatch());
 		} finally {
 			await client.close().catch(error => {
 				logger.warn(`SDK Broker session.list transport cleanup failed (${String(error)}).`);
@@ -1360,7 +1395,7 @@ export class SessionRouter {
 		// cannot keep the old attachment authorized.
 		const identityBefore = await lstatEndpoint(attached.endpoint.path);
 		if (!identityBefore || !sameEndpointIdentity(attached.endpointIdentity, identityBefore)) return false;
-		if (identityBefore.mtimeMs !== indexed.endpointMtimeMs) return false;
+		if (!matchesIndexedEndpointFile(identityBefore, indexed)) return false;
 		let raw: Record<string, unknown>;
 		try {
 			const parsed = JSON.parse(await Bun.file(attached.endpoint.path).text());
@@ -1384,7 +1419,7 @@ export class SessionRouter {
 		const identityAfter = await lstatEndpoint(attached.endpoint.path);
 		return (
 			identityAfter !== undefined &&
-			identityAfter.mtimeMs === indexed.endpointMtimeMs &&
+			matchesIndexedEndpointFile(identityAfter, indexed) &&
 			sameEndpointIdentity(attached.endpointIdentity, identityAfter)
 		);
 	}
@@ -1416,7 +1451,7 @@ export class SessionRouter {
 		const endpointIdentity = await lstatEndpoint(endpointPath);
 		const endpoint = await readSdkSessionEndpoint(cwd, indexed.sessionId, scope);
 		if (!endpoint || endpoint.stale || endpoint.pid !== indexed.pid) return null;
-		if (!endpointIdentity || endpointIdentity.mtimeMs !== indexed.endpointMtimeMs) return null;
+		if (!endpointIdentity || !matchesIndexedEndpointFile(endpointIdentity, indexed)) return null;
 		// Identity is proven INSIDE this authority read (#4730 review): sampling it
 		// afterwards would let an identical rename between the read and the sample
 		// install the replacement's inode as the trusted baseline.
@@ -1441,7 +1476,7 @@ export class SessionRouter {
 		const endpointIdentityAfterRead = await lstatEndpoint(endpoint.path);
 		if (
 			!endpointIdentityAfterRead ||
-			endpointIdentityAfterRead.mtimeMs !== indexed.endpointMtimeMs ||
+			!matchesIndexedEndpointFile(endpointIdentityAfterRead, indexed) ||
 			!sameEndpointIdentity(endpointIdentity, endpointIdentityAfterRead)
 		)
 			return null;
@@ -1641,7 +1676,13 @@ export class SessionRouter {
 				return attached?.client.connectionId;
 			},
 			isCurrent: () => attached !== undefined && this.#attachmentPublished(attached),
-			send: async (frame: Record<string, unknown>) => {
+			send: async (
+				frame: Record<string, unknown>,
+				options?: {
+					beforeDispatch?: () => void;
+					dispatchFence?: (dispatch: () => Promise<void>) => Promise<void>;
+				},
+			) => {
 				if (!attached || !this.#attachmentPublished(attached))
 					throw new SessionRouterError("pre_send", "SDK session attachment is stale.");
 				if (attached.initializingPublication) {
@@ -1659,7 +1700,17 @@ export class SessionRouter {
 				} else await this.#serialReconcile(runEpoch, true, true);
 				if (!attached || !this.#attachmentPublished(attached))
 					throw new SessionRouterError("pre_send", "SDK session attachment is stale.");
-				attached.client.send(this.#prepareFrame(attached, frame));
+				const dispatchAttachment = attached;
+				const dispatch = async () => {
+					options?.beforeDispatch?.();
+					try {
+						dispatchAttachment.client.send(this.#prepareFrame(dispatchAttachment, frame));
+					} catch (error) {
+						if (error instanceof SdkClientError) throw new SdkPreparedDispatchError(error);
+						throw error;
+					}
+				};
+				await (options?.dispatchFence ? options.dispatchFence(dispatch) : dispatch());
 			},
 			/**
 			 * Provider-lease heartbeats skip the pre-send authority reconcile

package/src/sdk/session-api-key.ts

@@ -0,0 +1,94 @@
+/**
+ * AgentLoop calls `getApiKey(provider)` before `streamFn`.
+ * Resolve/stream already use `getApiKey(model)`. If those two lookups diverge,
+ * the child dies locally (~8ms, 0 tokens, sanitized "Agent run failed.")
+ * and never reaches the working model-scoped path (#5081).
+ */
+export type SessionApiKeyModel = {
+	provider: string;
+	baseUrl?: string;
+};
+
+export type SessionApiKeyRegistry = {
+	getApiKey(
+		model: SessionApiKeyModel,
+		sessionId?: string,
+		options?: { signal?: AbortSignal },
+	): Promise<string | undefined>;
+	getApiKeyForProvider(
+		provider: string,
+		sessionId?: string,
+		baseUrl?: string,
+		options?: { signal?: AbortSignal },
+	): Promise<string | undefined>;
+};
+
+export type SessionApiKeyResolution = {
+	apiKey: string;
+	credentialSessionId: string | undefined;
+};
+
+export type SessionApiKeyCredentialType = "api_key" | "oauth" | undefined;
+
+export function isStableSessionApiKeyCredentialType(
+	previous: SessionApiKeyCredentialType,
+	replacement: SessionApiKeyCredentialType,
+): boolean {
+	return previous === replacement;
+}
+
+export function resolveLiveSessionApiKeyModel(
+	live: SessionApiKeyModel | undefined,
+	captured: SessionApiKeyModel | undefined,
+	provider: string,
+): SessionApiKeyModel | undefined {
+	if (live?.provider === provider) return live;
+	if (captured?.provider === provider) return captured;
+	return undefined;
+}
+
+async function lookupOnce(
+	registry: SessionApiKeyRegistry,
+	provider: string,
+	sessionId: string | undefined,
+	model: SessionApiKeyModel | undefined,
+	signal: AbortSignal | undefined,
+): Promise<string | undefined> {
+	signal?.throwIfAborted();
+	const matchingModel = model?.provider === provider ? model : undefined;
+	const options = signal ? { signal } : undefined;
+	let key: string | undefined;
+	if (matchingModel) {
+		key = await registry.getApiKey(matchingModel, sessionId, options);
+		signal?.throwIfAborted();
+	}
+	if (!key) {
+		key = await registry.getApiKeyForProvider(provider, sessionId, matchingModel?.baseUrl, options);
+		signal?.throwIfAborted();
+	}
+	return key;
+}
+
+export async function lookupSessionApiKey(
+	registry: SessionApiKeyRegistry,
+	provider: string,
+	sessionId: string | undefined,
+	model: SessionApiKeyModel | undefined,
+	allowUnscopedRetry = true,
+	signal?: AbortSignal,
+): Promise<SessionApiKeyResolution> {
+	let key = await lookupOnce(registry, provider, sessionId, model, signal);
+	// Architect children inherit the parent SID. Direct `-p --no-session` does
+	// not. Scoped miss then global/broker hit is the remaining 0-token death
+	// after #5105 (jsonl: Agent run failed / output 0).
+	if (!key && sessionId && allowUnscopedRetry) {
+		key = await lookupOnce(registry, provider, undefined, model, signal);
+		if (key) return { apiKey: key, credentialSessionId: undefined };
+	}
+	if (!key) {
+		throw Object.assign(new Error(`No API key found for provider "${provider}"`), {
+			code: "provider_unavailable",
+		});
+	}
+	return { apiKey: key, credentialSessionId: sessionId };
+}