@gajae-code/coding-agent 0.12.7 → 0.12.8

package/src/sdk/host/query/handlers.ts

@@ -1,4 +1,6 @@
 import { PROMPT_CLIENT_REF_MAX_LENGTH } from "../../prompt-status.js";
+import type { ActiveProviderDescriptor } from "../../providers.js";
+import { ActiveProviderResolutionError } from "../../providers.js";
 import {
 	assertCursorSelector,
 	type CursorEnvelope,
@@ -22,6 +24,7 @@ export interface SessionSurface {
 	getUsage(): unknown | Promise<unknown>;
 	getModels(): unknown | Promise<unknown>;
 	getSkillState(): unknown | Promise<unknown>;
+	getActiveProviders?(): ActiveProviderDescriptor[] | Promise<ActiveProviderDescriptor[]>;
 	/** Q12 rows preserve workflow gate fields and include stable durable gate metadata. */
 	getGates(): unknown | Promise<unknown>;
 	getConfigItems(): unknown | Promise<unknown>;
@@ -102,6 +105,7 @@ const sources: Record<string, { resource: string; method: keyof SessionSurface;
 	Q21: { resource: "queue", method: "getQueueMessages", mvcc: true },
 	Q22: { resource: "extensions", method: "getExtensions", mvcc: true },
 	Q25: { resource: "jobs", method: "getJobs", mvcc: false },
+	Q29: { resource: "activeProviders", method: "getActiveProviders", mvcc: false },
 	Q27: { resource: "modelProfiles", method: "getModelProfiles", mvcc: true },
 };
 const names = [
@@ -133,6 +137,7 @@ const names = [
 	"turn.prompt_status",
 	"models.profiles.list",
 	"skill.invoke_status",
+	"providers.list/active",
 ];
 
 export class QueryHandlers {
@@ -168,6 +173,15 @@ export class QueryHandlers {
 				return this.#error(request, "invalid_request", false, "models.profiles.list does not accept input fields.");
 			if (query === "Q27" && typeof this.surface.getModelProfiles !== "function")
 				return this.#error(request, "unavailable", false, "models.profiles.list is unavailable for this session.");
+			if (query === "Q29" && request.input && Object.keys(request.input).length > 0)
+				return this.#error(
+					request,
+					"invalid_request",
+					false,
+					"providers.list/active does not accept input fields.",
+				);
+			if (query === "Q29" && typeof this.surface.getActiveProviders !== "function")
+				return this.#error(request, "unavailable", false, "providers.list/active is unavailable for this session.");
 			const source = sources[query];
 			if (!source) return this.#error(request, "invalid_request");
 			return await this.#pageSource(request, query, source);
@@ -257,7 +271,12 @@ export class QueryHandlers {
 				source.resource === "transcript" ? { highWatermark: cursor.highWatermark } : {},
 			);
 		} else {
-			snapshot = await (this.surface[source.method] as () => unknown)();
+			try {
+				snapshot = await (this.surface[source.method] as () => unknown)();
+			} catch (error) {
+				if (queryId === "Q29") throw new ActiveProviderResolutionError();
+				throw error;
+			}
 			revision = await this.revisions.createRevision(source.resource, resourceId, snapshot);
 		}
 		if (snapshot === undefined) return this.#error(request, "resource_gone");

package/src/sdk/index.ts

@@ -22,5 +22,6 @@ export type {
 	Q10ThinkingMode,
 } from "./models";
 export * from "./prompt-status";
+export type { ActiveProviderConnectionKind, ActiveProviderDescriptor } from "./providers";
 export * from "./session";
 export * from "./session-directory";

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

@@ -1583,6 +1583,24 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "registry:Q29",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "providers.list/active",
+		"adapterMappings": {
+			"telegram": "prohibited",
+			"discord": "prohibited",
+			"slack": "prohibited",
+			"mcp": "generic_safe",
+			"acp": "generic_safe",
+			"daemonCli": "generic_safe"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
 	{
 		"sourceId": "registry:R01",
 		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",

package/src/sdk/protocol/operation-registry.ts

@@ -164,6 +164,7 @@ const queries = [
 		"skill.invoke_status",
 		"Read the authoritative reconciliation status of a skill.invoke by command/turn IDs or clientRef.",
 	],
+	["providers.list/active", "List active providers."],
 ] as const;
 
 const reverse = [
@@ -243,7 +244,7 @@ function queryContinuityClass(id: string): QueryContinuityClass {
 }
 
 function queryDisposition(id: string): Record<Adapter, AdapterDisposition> {
-	if (["Q23", "Q24", "Q25", "Q26", "Q27", "Q28"].includes(id))
+	if (["Q23", "Q24", "Q25", "Q26", "Q27", "Q28", "Q29"].includes(id))
 		return dispositions({ telegram: "prohibited", discord: "prohibited", slack: "prohibited" });
 	return dispositions();
 }
@@ -306,7 +307,9 @@ export const OPERATIONS: readonly Operation[] = [
 			errorCodes:
 				id === "Q27"
 					? ["invalid_request", "resource_gone", "model_profile_registry_error"]
-					: ["invalid_request", "resource_gone"],
+					: id === "Q29"
+						? ["invalid_request", "resource_gone", "internal"]
+						: ["invalid_request", "resource_gone"],
 			continuityClass: queryContinuityClass(id),
 			adapterDispositions: queryDisposition(id),
 			testIds: ["packages/coding-agent/test/sdk-operation-inventory.test.ts"],

package/src/sdk/providers.ts

@@ -0,0 +1,51 @@
+export type ActiveProviderConnectionKind = "credential" | "credentialless";
+
+export interface ActiveProviderDescriptor {
+	provider: string;
+	connectionKind: ActiveProviderConnectionKind;
+}
+function compareProviderIdsByUtf8(left: string, right: string): number {
+	const leftBytes = new TextEncoder().encode(left);
+	const rightBytes = new TextEncoder().encode(right);
+	const length = Math.min(leftBytes.length, rightBytes.length);
+	for (let index = 0; index < length; index += 1) {
+		const difference = leftBytes[index]! - rightBytes[index]!;
+		if (difference !== 0) return difference;
+	}
+	return leftBytes.length - rightBytes.length;
+}
+
+/**
+ * Project active-provider inputs to the exact public DTO shape.
+ *
+ * Connection credentials take precedence when the same provider is reported
+ * more than once. Provider IDs are sorted by their UTF-8 bytes without
+ * normalization.
+ */
+export function projectActiveProviderDescriptors(
+	descriptors: readonly { provider: string; connectionKind: unknown }[],
+): ActiveProviderDescriptor[] {
+	const active = new Map<string, ActiveProviderConnectionKind>();
+	for (const descriptor of descriptors) {
+		if (descriptor.connectionKind !== "credential" && descriptor.connectionKind !== "credentialless") {
+			throw new Error("Invalid active provider connection kind.");
+		}
+		if (active.get(descriptor.provider) === "credential") continue;
+		active.set(descriptor.provider, descriptor.connectionKind);
+	}
+	return [...active.entries()]
+		.sort(([left], [right]) => compareProviderIdsByUtf8(left, right))
+		.map(([provider, connectionKind]) => ({ provider, connectionKind }));
+}
+
+export const ACTIVE_PROVIDER_RESOLUTION_ERROR_CODE = "internal" as const;
+export const ACTIVE_PROVIDER_RESOLUTION_ERROR_MESSAGE = "Unable to resolve active providers.";
+
+export class ActiveProviderResolutionError extends Error {
+	readonly code = ACTIVE_PROVIDER_RESOLUTION_ERROR_CODE;
+
+	constructor() {
+		super(ACTIVE_PROVIDER_RESOLUTION_ERROR_MESSAGE);
+		this.name = "ActiveProviderResolutionError";
+	}
+}

package/src/sdk/session-directory.ts

@@ -39,6 +39,7 @@ export type ResolveManagedSessionScopeResult =
 				| "sessions_root_unavailable"
 				| "binding_conflict"
 				| "binding_invalid"
+				| "migration_busy"
 				| "atomic_unavailable"
 				| "durability_not_provable"
 				| "durability_failed"

package/src/sdk/session.ts

@@ -108,10 +108,10 @@ import { MCPManager } from "../runtime-mcp";
 import { createNotificationsExtension } from "../sdk/bus";
 import {
 	getNotificationConfig,
-	isNotificationHostEligible,
+	isGenericNotificationHostEligible,
 	type NotificationConfig,
 	SPAWN_PROVENANCE_ENV,
-	shouldRegisterNotificationsExtension,
+	shouldRegisterGenericNotificationsExtension,
 } from "../sdk/bus/config";
 import { NotificationSessionController } from "../sdk/bus/session-control";
 import { shouldHostSdk } from "../sdk/host";
@@ -184,6 +184,7 @@ import {
 
 type AsyncResultEntry = {
 	jobId: string;
+	generation: string;
 	result: string;
 	job: AsyncJob | undefined;
 	durationMs: number | undefined;
@@ -1502,13 +1503,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				? new AsyncJobManager({
 						maxRunningJobs: asyncMaxJobs,
 						onJobComplete: async (jobId, result, job) => {
-							if (!session || asyncJobManager!.isDeliverySuppressed(jobId)) return;
+							if (!session) return;
 							const formattedResult = await formatAsyncResultForFollowUp(result);
-							if (asyncJobManager!.isDeliverySuppressed(jobId)) return;
+							if (asyncJobManager!.isDeliverySuppressed(jobId, job?.generation)) return;
 
 							const durationMs = job ? jobElapsedMs(job) : undefined;
 							session.yieldQueue.enqueue<AsyncResultEntry>("async-result", {
 								jobId,
+								generation: job?.generation ?? "",
 								result: formattedResult,
 								job,
 								durationMs,
@@ -1907,7 +1909,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const spawnProvenance = process.env[SPAWN_PROVENANCE_ENV];
 		const spawnedByGjc = typeof spawnProvenance === "string" && spawnProvenance.trim().length > 0;
 		delete process.env[SPAWN_PROVENANCE_ENV];
-		const notificationHostEligible = isNotificationHostEligible({
+		const notificationHostEligible = isGenericNotificationHostEligible({
 			env: process.env,
 			hostModeSupported: options.notificationHostModeSupported ?? true,
 			taskDepth,
@@ -1919,10 +1921,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		const notificationSessionController = new NotificationSessionController({
 			eligible: notificationHostEligible,
 			getConfig: () => getNotificationConfig(settings),
+			spawnedByGjc,
 		});
 		if (
 			lifecycleStartupCapability ||
-			shouldRegisterNotificationsExtension({
+			shouldRegisterGenericNotificationsExtension({
 				env: process.env,
 				cfg: notificationCfg,
 				taskDepth,
@@ -2797,7 +2800,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		hasSession = true;
 		if (asyncJobManager) {
 			session.yieldQueue.register<AsyncResultEntry>("async-result", {
-				isStale: entry => asyncJobManager.isDeliverySuppressed(entry.jobId),
+				isStale: entry => asyncJobManager.isDeliverySuppressed(entry.jobId, entry.generation),
 				build: buildAsyncResultBatchMessage,
 			});
 		}

package/src/session/agent-session.ts

@@ -1869,13 +1869,6 @@ export class AgentSession {
 		this.#retryReplayEpoch++;
 		this.#retryReplayUnsafeEpoch = undefined;
 		this.#firstEventTimeoutRetryStartedAt = Date.now();
-		if (
-			this.#extensionRunner?.hasHandlers("context") ||
-			this.#extensionRunner?.hasHandlers("before_provider_request") ||
-			this.#extensionRunner?.hasHandlers("after_provider_response")
-		) {
-			this.#markRetryReplayUnsafe();
-		}
 	}
 
 	#markRetryReplayUnsafe(): void {
@@ -1885,6 +1878,14 @@ export class AgentSession {
 	get #hasCleanRetryReplaySafety(): boolean {
 		return this.#retryReplayEpoch > 0 && this.#retryReplayUnsafeEpoch !== this.#retryReplayEpoch;
 	}
+	#bindAttemptScope(scope: AttemptScope | undefined): void {
+		if (!scope) return;
+		this.#attemptRecordStore.register(scope);
+		this.#attemptRecordStore.establishClean(scope);
+	}
+	#isRetryScopeClean(scope: AttemptScope | undefined): boolean {
+		return scope !== undefined && this.#attemptRecordStore.isClean(scope);
+	}
 	#prePromptContextCheckPromise: Promise<void> | undefined = undefined;
 	/** Display-only context snapshot; pre-prompt compaction estimates deliberately remain uncached. */
 	#contextUsageCache: { key: string; value: ContextUsage } | undefined;
@@ -1898,6 +1899,8 @@ export class AgentSession {
 	// Handoff state
 	#handoffAbortController: AbortController | undefined = undefined;
 	#skipPostTurnMaintenanceAssistantTimestamp: number | undefined = undefined;
+	/** Scope cleanliness captured after message_end extension delivery and before terminal agent_end retirement. */
+	#assistantAttemptScopes = new WeakMap<AssistantMessage, { scope?: AttemptScope; wasClean: boolean }>();
 
 	// Retry state
 	#retryAbortController: AbortController | undefined = undefined;
@@ -2606,6 +2609,7 @@ export class AgentSession {
 		if (this.#extensionRunner && typeof this.#extensionRunner.setAttemptRecordStore === "function") {
 			this.#extensionRunner.setAttemptRecordStore(this.#attemptRecordStore);
 		}
+		this.agent.setMainAttemptScopeObserver(scope => this.#bindAttemptScope(scope));
 		this.#skills = config.skills ?? [];
 		this.#skillWarnings = config.skillWarnings ?? [];
 		this.#customCommands = config.customCommands ?? [];
@@ -3739,11 +3743,7 @@ export class AgentSession {
 	/** Internal handler for agent events - shared by subscribe and reconnect */
 	#handleAgentEvent = async (event: AgentEvent, activePromptHandle?: string): Promise<void> => {
 		const attemptScope = (event as AgentEvent & { scope?: AttemptScope }).scope;
-		if ((event.type === "agent_start" || event.type === "turn_start") && attemptScope) {
-			this.#attemptRecordStore.register(attemptScope);
-			this.#attemptRecordStore.establishClean(attemptScope);
-		}
-		if (this.#extensionRunner?.hasHandlers(event.type)) this.#markRetryReplayUnsafe();
+
 		if (
 			event.type === "tool_execution_start" ||
 			event.type === "tool_execution_update" ||
@@ -3947,6 +3947,12 @@ export class AgentSession {
 		}
 
 		await this.#emitSessionEvent(displayEvent);
+		if (event.type === "message_end" && event.message.role === "assistant") {
+			this.#assistantAttemptScopes.set(event.message, {
+				scope: attemptScope,
+				wasClean: this.#isRetryScopeClean(attemptScope),
+			});
+		}
 		if (
 			displayEvent !== event &&
 			displayEvent.type === "message_end" &&
@@ -4321,7 +4327,14 @@ export class AgentSession {
 			if (this.#isRetryableError(msg)) {
 				const transportFailure = (msg as AssistantMessage & { transportFailure?: TransportFailureFacts })
 					.transportFailure;
-				const didRetry = await this.#handleRetryableError(msg, false, transportFailure);
+				const messageScope = this.#assistantAttemptScopes.get(msg);
+				const didRetry = await this.#handleRetryableError(
+					msg,
+					false,
+					transportFailure,
+					messageScope?.scope ?? event.scope,
+					messageScope?.wasClean ?? false,
+				);
 				if (didRetry) return; // Retry was initiated, don't proceed to compaction
 			}
 			if (this.#retryAttempt > 0) {
@@ -5838,6 +5851,7 @@ export class AgentSession {
 		this.#abortActiveMidRunBarriers();
 		this.abortCompaction();
 		this.agent.abort();
+		this.agent.setMainAttemptScopeObserver(undefined);
 		// Disconnect the Agent event bridge NOW — before the maintenance join and the
 		// bounded idle / forceAbort below — so no agent_end emitted during teardown
 		// (including the one forceAbort emits) can re-enter #handleAgentEvent and start
@@ -14573,6 +14587,8 @@ export class AgentSession {
 			outcome.failure.message,
 			true,
 			outcome.failure.transportFailure,
+			outcome.scope,
+			this.#isRetryScopeClean(outcome.scope),
 		) as Promise<ManagedAttemptDecision>;
 	}
 
@@ -14733,6 +14749,8 @@ export class AgentSession {
 		message: AssistantMessage,
 		managedOutcome = false,
 		transportFailure?: TransportFailureFacts,
+		scope?: AttemptScope,
+		scopeWasClean = this.#isRetryScopeClean(scope),
 	): Promise<boolean | ManagedAttemptDecision> {
 		const controller = this.#defaultFallbackChain();
 		const managedFallback = controller.chain.entries.length > 1;
@@ -14747,12 +14765,16 @@ export class AgentSession {
 		if (!managedFallback && !retrySettings.enabled) return false;
 		const classification = this.#classifyErrorForRetry(message);
 		const firstEventTimeout = classification === "first_event_timeout";
-		if (!managedFallback && firstEventTimeout) {
-			this.#firstEventTimeoutRetryStartedAt ??= Date.now();
+		if (!managedFallback && firstEventTimeout && this.#retryAttempt === 0) {
+			this.#firstEventTimeoutRetryStartedAt = Date.now();
 		}
-		// First-event timeouts are replay-safe only before any model progress,
-		// abort, or extension/provider lifecycle participation.
-		if (firstEventTimeout && (!this.#hasCleanRetryReplaySafety || assistantMessageHasVisibleOrToolContent(message))) {
+		const requiresScopedFirstEventTimeout = managedFallback || !legacyRetryConfigured;
+		if (
+			firstEventTimeout &&
+			(assistantMessageHasVisibleOrToolContent(message) ||
+				(this.#retryAttempt > 0 && !this.#hasCleanRetryReplaySafety) ||
+				(requiresScopedFirstEventTimeout && (!this.#isTypedFirstEventTimeout(message) || !scope || !scopeWasClean)))
+		) {
 			return managedOutcome
 				? {
 						type: "terminal",
@@ -14780,14 +14802,12 @@ export class AgentSession {
 		// before the failure. This bypasses #hasCleanRetryReplaySafety because the
 		// content-free check is the replay-safety guarantee for credential rotation.
 		const canReplayRotatedCredential = credentialRotated;
-		// Bare defaults admit only clean, side-effect-free canonical stream watchdog failures,
-		// content-free quota/rate-limit credential rotations, and the explicit Codex
-		// capacity-overload event.
+		// Bare defaults retain their narrow watchdog and Codex admissions. A
+		// first-event timeout adds the typed, content-free, current-clean-scope
+		// requirement above; other transient watchdogs preserve legacy behavior.
 		if (!managedFallback && !legacyRetryConfigured && !canReplayRotatedCredential) {
 			const bareDefaultCodexOverload = isBareDefaultCodexOverload(message);
 			const bareDefaultWrappedFirstEventTimeout = isBareDefaultWrappedFirstEventTimeout(message);
-			// Content-free Codex overload is replay-safe by the same reasoning as
-			// credential rotation: no partial output means no observable state.
 			const canReplayCodexOverload = bareDefaultCodexOverload;
 			if (
 				(!canReplayCodexOverload &&
@@ -14796,7 +14816,7 @@ export class AgentSession {
 					(hasBareDefaultRetryDisqualifyingFacts(message) ||
 						(classification !== "transient" && classification !== "first_event_timeout") ||
 						!BARE_DEFAULT_WATCHDOG_ERROR.test(message.errorMessage ?? ""))) ||
-				(!canReplayCodexOverload && !this.#hasCleanRetryReplaySafety)
+				(!canReplayCodexOverload && !firstEventTimeout && !this.#hasCleanRetryReplaySafety)
 			) {
 				return false;
 			}