@gajae-code/coding-agent 0.11.10 → 0.12.0

package/src/sdk/host/control/dispatch.ts

@@ -158,7 +158,11 @@ function invoke(
 		case "workflow.plan_approve":
 			return surface.approvePlan(text(input, "id"), input.choice, input.expectedSessionId as string | undefined);
 		case "skill.invoke":
-			return surface.invokeSkill(text(input, "name"), input.args);
+			return surface.invokeSkill(
+				text(input, "name"),
+				input.args,
+				typeof input.clientRef === "string" ? input.clientRef : undefined,
+			);
 		case "mode.plan.set":
 			return surface.setPlanMode(input.on as boolean);
 		case "mode.goal.operate":
@@ -167,6 +171,8 @@ function invoke(
 			return surface.replaceTodo(input.items);
 		case "model.set":
 			return surface.setModel(text(input, "id"), input.thinkingLevel);
+		case "model.profile.set":
+			return surface.setModelProfile(text(input, "id"));
 		case "model.cycle":
 			return surface.cycleModel();
 		case "thinking.set":

package/src/sdk/host/control/operations.ts

@@ -19,11 +19,12 @@ export interface ControlSurface {
 		idempotencyKey?: string,
 	): Promise<ControlValue> | ControlValue;
 	approvePlan(id: string, choice: ControlValue, expectedSessionId?: string): Promise<ControlValue> | ControlValue;
-	invokeSkill(name: string, args: ControlValue): Promise<ControlValue> | ControlValue;
+	invokeSkill(name: string, args: ControlValue, clientRef?: string): Promise<ControlValue> | ControlValue;
 	setPlanMode(on: boolean): Promise<ControlValue> | ControlValue;
 	operateGoal(op: string, objective?: string): Promise<ControlValue> | ControlValue;
 	replaceTodo(items: ControlValue): Promise<ControlValue> | ControlValue;
 	setModel(id: string, thinkingLevel?: ControlValue): Promise<ControlValue> | ControlValue;
+	setModelProfile(id: string): Promise<ControlValue> | ControlValue;
 	cycleModel(): Promise<ControlValue> | ControlValue;
 	setThinking(level: ControlValue): Promise<ControlValue> | ControlValue;
 	cycleThinking(): Promise<ControlValue> | ControlValue;

package/src/sdk/host/host.ts

@@ -9,6 +9,13 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	query?: (connectionId: string, frame: SdkFrame) => unknown | Promise<unknown>;
 	/** Best-effort diagnostic observation of accepted control/query frames. */
 	onRequest?: SdkRequestObserver;
+	/** Runs before a control response is sent; identity transitions use sendTerminal. */
+	beforeControlResponse?: (
+		connectionId: string,
+		request: SdkFrame,
+		response: SdkFrame,
+		sendTerminal: () => Promise<void>,
+	) => void | Promise<void>;
 	/** Runs only after a successful control response has been sent to the client. */
 	afterControlResponse?: (connectionId: string, request: SdkFrame, response: SdkFrame) => void | Promise<void>;
 	installProviderDefinitions?: (capability: string, definitions: unknown) => void;
@@ -18,7 +25,7 @@ export interface SessionSdkHostOptions extends HostEndpointAdapters {
 	connectionCapabilities?: (connectionId: string) => ReadonlySet<string> | undefined;
 }
 
-const TOOL_ACTIVITY_V1 = "tool_activity_v1";
+const TOOL_ACTIVITY_CAPABILITY = "tool_activity_v2";
 const CAP_GATED_FRAME_KINDS = new Set(["tool_activity", "reasoning_summary"]);
 const EMPTY_CAPABILITIES: ReadonlySet<string> = new Set();
 
@@ -36,6 +43,14 @@ function errorFrame(connectionId: string, frame: SdkFrame, error: unknown): SdkF
 				? candidate.code
 				: "internal";
 	const message = typeof candidate?.message === "string" ? candidate.message : "SDK host operation failed.";
+	if (frame.type === "control_request") {
+		return {
+			type: "control_response",
+			id: typeof frame.id === "string" ? frame.id : "",
+			ok: false,
+			error: { code, message },
+		};
+	}
 	return {
 		type: "reverse_response",
 		id: typeof frame.id === "string" ? frame.id : "",
@@ -214,7 +229,14 @@ export class SessionSdkHost {
 					const result = await this.#options.control?.(connectionId, frame);
 					if (result !== undefined) {
 						const response = { type: "control_response", ...(result as SdkFrame) };
-						await this.#send(connectionId, response);
+						let terminalSent = false;
+						const sendTerminal = async (): Promise<void> => {
+							if (terminalSent) return;
+							terminalSent = true;
+							await this.#send(connectionId, response);
+						};
+						await this.#options.beforeControlResponse?.(connectionId, frame, response, sendTerminal);
+						await sendTerminal();
 						await this.#options.afterControlResponse?.(connectionId, frame, response);
 					}
 					break;
@@ -233,7 +255,7 @@ export class SessionSdkHost {
 					const replay = this.events.replay(sinceSeq, sinceGeneration);
 					const capabilities = this.#options.connectionCapabilities?.(connectionId) ?? EMPTY_CAPABILITIES;
 					const events = replay.events.filter(
-						event => !CAP_GATED_FRAME_KINDS.has(String(event.kind)) || capabilities.has(TOOL_ACTIVITY_V1),
+						event => !CAP_GATED_FRAME_KINDS.has(String(event.kind)) || capabilities.has(TOOL_ACTIVITY_CAPABILITY),
 					);
 					await this.#send(connectionId, {
 						type: "event_replay_result",

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

@@ -46,6 +46,11 @@ export interface SessionSurface {
 	getJobs(): unknown | Promise<unknown>;
 	/** Q26 keyed lookup of a submitted prompt's authoritative reconciliation status. */
 	getPromptStatus?(selector: { commandId?: string; turnId?: string; clientRef?: string }): unknown | Promise<unknown>;
+	getSkillInvokeStatus?(selector: {
+		commandId?: string;
+		turnId?: string;
+		clientRef?: string;
+	}): unknown | Promise<unknown>;
 	/** Q27 effective model-profile catalog from the live session registry. */
 	getModelProfiles?(): unknown[] | Promise<unknown[]>;
 	/** Query rows backed by the session's installed binding map. */
@@ -127,6 +132,7 @@ const names = [
 	"runtime.jobs.list",
 	"turn.prompt_status",
 	"models.profiles.list",
+	"skill.invoke_status",
 ];
 
 export class QueryHandlers {
@@ -156,6 +162,7 @@ export class QueryHandlers {
 			if (query === "Q02") return await this.#transcriptBody(request);
 			if (query === "Q23") return await this.#resourceBody(request);
 			if (query === "Q26") return await this.#promptStatus(request);
+			if (query === "Q28") return await this.#skillInvokeStatus(request);
 			if (query === "Q24") return await this.#artifact(request);
 			if (query === "Q27" && request.input && Object.keys(request.input).length > 0)
 				return this.#error(request, "invalid_request", false, "models.profiles.list does not accept input fields.");
@@ -517,6 +524,54 @@ export class QueryHandlers {
 		return { id: request.id, ok: true, page };
 	}
 
+	async #skillInvokeStatus(request: QueryRequest): Promise<QueryResponse> {
+		if (request.cursor)
+			return this.#error(request, "invalid_request", false, "skill.invoke_status does not support cursors.");
+		const input = request.input ?? {};
+		for (const key of Object.keys(input))
+			if (key !== "commandId" && key !== "turnId" && key !== "clientRef")
+				return this.#error(
+					request,
+					"invalid_request",
+					false,
+					`skill.invoke_status does not accept selector field "${key}".`,
+				);
+		const commandId = typeof input.commandId === "string" && input.commandId ? input.commandId : undefined;
+		const turnId = typeof input.turnId === "string" && input.turnId ? input.turnId : undefined;
+		const rawClientRef = typeof input.clientRef === "string" ? input.clientRef : undefined;
+		const trimmedClientRef = rawClientRef?.trim();
+		if (rawClientRef !== undefined && (!trimmedClientRef || trimmedClientRef.length > PROMPT_CLIENT_REF_MAX_LENGTH))
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"clientRef must be a non-empty string of at most 128 characters.",
+			);
+		const clientRef = trimmedClientRef || undefined;
+		if ((commandId === undefined) !== (turnId === undefined))
+			return this.#error(request, "invalid_request", false, "commandId and turnId must be provided together.");
+		if (commandId !== undefined && clientRef !== undefined)
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"Provide exactly one selector: a commandId/turnId pair or a clientRef.",
+			);
+		if (commandId === undefined && clientRef === undefined)
+			return this.#error(
+				request,
+				"invalid_request",
+				false,
+				"skill.invoke_status requires a commandId/turnId pair or a clientRef.",
+			);
+		if (typeof this.surface.getSkillInvokeStatus !== "function")
+			return this.#error(request, "unavailable", false, "skill.invoke_status is unavailable for this session.");
+		const result = await this.surface.getSkillInvokeStatus(
+			clientRef !== undefined ? { clientRef } : { commandId: commandId!, turnId: turnId! },
+		);
+		return { id: request.id, ok: true, result };
+	}
+
 	async #promptStatus(request: QueryRequest): Promise<QueryResponse> {
 		if (request.cursor)
 			return this.#error(request, "invalid_request", false, "turn.prompt_status does not support cursors.");

package/src/sdk/lifecycle-session.ts

@@ -1,6 +1,7 @@
 import type { AgentSession } from "../session/agent-session";
 import { type CreateAgentSessionOptions, createAgentSession } from "./session";
 import {
+	lifecycleMcpStartupTimeoutOption,
 	lifecycleStartupCapabilityOption,
 	SdkStartupCapability,
 	type SdkStartupFailure,
@@ -15,17 +16,32 @@ export type CreateLifecycleAgentSessionResult =
 	  }
 	| { capability: SdkStartupCapability; rollback: SdkStartupRollbackTracker; failure: SdkStartupFailure };
 
+/** Options accepted by lifecycle-only session construction. */
+export type CreateLifecycleAgentSessionOptions = CreateAgentSessionOptions & {
+	/**
+	 * Startup budget for ACP lifecycle MCP launches, in milliseconds. Set only
+	 * when the lifecycle request supplies `mcpServers`; ordinary consumers keep
+	 * the manager's short default ceiling.
+	 */
+	mcpStartupTimeoutMs?: number;
+};
+
 /** Internal lifecycle-only session construction with an owner-bound SDK startup result. */
 export async function createLifecycleAgentSession(
-	options: CreateAgentSessionOptions = {},
+	options: CreateLifecycleAgentSessionOptions = {},
 ): Promise<CreateLifecycleAgentSessionResult> {
 	const rollback = new SdkStartupRollbackTracker();
 	const capability = new SdkStartupCapability(rollback);
 	try {
+		const { mcpStartupTimeoutMs, ...sessionOptions } = options;
 		const internalOptions = {
-			...options,
+			...sessionOptions,
 			[lifecycleStartupCapabilityOption]: capability,
-		} as CreateAgentSessionOptions & { [lifecycleStartupCapabilityOption]: SdkStartupCapability };
+			...(mcpStartupTimeoutMs !== undefined ? { [lifecycleMcpStartupTimeoutOption]: mcpStartupTimeoutMs } : {}),
+		} as CreateAgentSessionOptions & {
+			[lifecycleStartupCapabilityOption]: SdkStartupCapability;
+			[lifecycleMcpStartupTimeoutOption]?: number;
+		};
 		const result = await createAgentSession(internalOptions);
 		if (!result.session.extensionRunner)
 			capability.settleFailure(capability.normalizeFailure("registration", "runner_absent"));

package/src/sdk/mcp/server.ts

@@ -301,9 +301,16 @@ export function createSdkMcpServer(options: SdkMcpServerOptions = {}) {
 export async function runSdkMcpStdio(options: SdkMcpServerOptions = {}): Promise<void> {
 	const server = createSdkMcpServer(options);
 	let buffer = "";
+	const inflight = new Set<Promise<void>>();
 	process.stdin.setEncoding("utf8");
-	await new Promise<void>(resolve => {
-		process.stdin.on("data", (chunk: string) => {
+
+	const track = (work: Promise<void>): void => {
+		inflight.add(work);
+		void work.finally(() => inflight.delete(work));
+	};
+
+	await new Promise<void>((resolve, reject) => {
+		const onData = (chunk: string) => {
 			buffer += chunk;
 			let index = buffer.indexOf("\n");
 			while (index >= 0) {
@@ -311,22 +318,43 @@ export async function runSdkMcpStdio(options: SdkMcpServerOptions = {}): Promise
 				buffer = buffer.slice(index + 1);
 				index = buffer.indexOf("\n");
 				if (!line) continue;
-				void (async () => {
-					let request: JsonRpcRequest;
-					try {
-						request = JSON.parse(line) as JsonRpcRequest;
-					} catch {
-						process.stdout.write(
-							`${JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse_error" } })}\n`,
-						);
-						return;
-					}
-					const response = await server.handleJsonRpc(request);
-					// JSON-RPC notifications (no id) receive no response.
-					if (request.id !== undefined) process.stdout.write(`${JSON.stringify(response)}\n`);
-				})();
+				track(
+					(async () => {
+						let request: JsonRpcRequest;
+						try {
+							request = JSON.parse(line) as JsonRpcRequest;
+						} catch {
+							process.stdout.write(
+								`${JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse_error" } })}\n`,
+							);
+							return;
+						}
+						const response = await server.handleJsonRpc(request);
+						// JSON-RPC notifications (no id) receive no response.
+						if (request.id !== undefined) process.stdout.write(`${JSON.stringify(response)}\n`);
+					})(),
+				);
 			}
-		});
-		process.stdin.on("end", () => resolve());
+		};
+		const onEnd = () => {
+			process.stdin.off("data", onData);
+			process.stdin.off("end", onEnd);
+			process.stdin.off("error", onError);
+			resolve();
+		};
+		const onError = (error: Error) => {
+			process.stdin.off("data", onData);
+			process.stdin.off("end", onEnd);
+			process.stdin.off("error", onError);
+			reject(error);
+		};
+		process.stdin.on("data", onData);
+		process.stdin.on("end", onEnd);
+		process.stdin.on("error", onError);
 	});
+
+	// Stdin EOF must not drop in-flight tools/call handlers (WS connect/query).
+	// Awaiting them also prevents the process from exiting before responses flush,
+	// and lets clients close so the event loop can drain deterministically.
+	await Promise.allSettled([...inflight]);
 }

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

@@ -935,6 +935,24 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "registry:C53",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "model.profile.set",
+		"adapterMappings": {
+			"telegram": "generic_safe",
+			"discord": "generic_safe",
+			"slack": "generic_safe",
+			"mcp": "generic_safe",
+			"acp": "generic_safe",
+			"daemonCli": "generic_safe"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
 	{
 		"sourceId": "registry:G01",
 		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
@@ -1547,6 +1565,24 @@
 			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
 		]
 	},
+	{
+		"sourceId": "registry:Q28",
+		"sourceFile": "packages/coding-agent/src/sdk/protocol/operation-registry.ts",
+		"sourceKind": "registry",
+		"decision": "include",
+		"sdkId": "skill.invoke_status",
+		"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",
@@ -2885,6 +2921,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:restoreFromMemoryGuardCheckpoint",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal owner-recovery staged restore builder after durable claims/fencing, never a user-facing SDK operation",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:promoteRecoveryHydrationAfterOwnershipReadyFence",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -2918,6 +2965,17 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:buildPreparedDisplaySessionContext",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "exclude",
+		"rationale": "internal accessor/plumbing, not a user-facing control seam",
+		"exclusionMetadata": {
+			"adapterMappings": "not_applicable",
+			"testIds": "not_applicable"
+		}
+	},
 	{
 		"sourceId": "agent_session:convertMessagesToLlm",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
@@ -3721,6 +3779,24 @@
 			"testIds": "not_applicable"
 		}
 	},
+	{
+		"sourceId": "agent_session:activateModelProfileForControl",
+		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",
+		"sourceKind": "agent_session",
+		"decision": "include",
+		"sdkId": "model.profile.set",
+		"adapterMappings": {
+			"telegram": "generic_safe",
+			"discord": "generic_safe",
+			"slack": "generic_safe",
+			"mcp": "generic_safe",
+			"acp": "generic_safe",
+			"daemonCli": "generic_safe"
+		},
+		"testIds": [
+			"packages/coding-agent/test/sdk-operation-inventory.test.ts"
+		]
+	},
 	{
 		"sourceId": "agent_session:getConfiguredModelChain",
 		"sourceFile": "packages/coding-agent/src/session/agent-session.ts",

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

@@ -116,6 +116,7 @@ const controls = [
 	["retry.last", "Retry the last interrupted or failed turn."],
 	["retry.now", "Immediately retry pending backoff."],
 	["bash.background", "Move active managed bash to the background."],
+	["model.profile.set", "Activate a model profile for the current session."],
 ] as const;
 
 const globals = [
@@ -159,6 +160,10 @@ const queries = [
 		"Read the authoritative reconciliation status of a submitted prompt by command/turn IDs or clientRef.",
 	],
 	["models.profiles.list", "List the effective built-in and configured model profiles for this session."],
+	[
+		"skill.invoke_status",
+		"Read the authoritative reconciliation status of a skill.invoke by command/turn IDs or clientRef.",
+	],
 ] as const;
 
 const reverse = [
@@ -196,7 +201,8 @@ function controlDisposition(id: string): Record<Adapter, AdapterDisposition> {
 
 function controlErrors(id: string): string[] {
 	const errors: Record<string, string[]> = {
-		C01: ["client_ref_conflict", "reconciliation_capacity"],
+		C01: ["client_ref_conflict", "reconciliation_capacity", "reconciliation_persist_failed"],
+		C09: ["client_ref_conflict", "reconciliation_capacity", "reconciliation_persist_failed"],
 		C06: ["action_claimed"],
 		C07: ["action_claimed", "terminal_uncertain"],
 		C08: ["action_claimed", "terminal_uncertain"],
@@ -237,7 +243,7 @@ function queryContinuityClass(id: string): QueryContinuityClass {
 }
 
 function queryDisposition(id: string): Record<Adapter, AdapterDisposition> {
-	if (["Q23", "Q24", "Q25", "Q26", "Q27"].includes(id))
+	if (["Q23", "Q24", "Q25", "Q26", "Q27", "Q28"].includes(id))
 		return dispositions({ telegram: "prohibited", discord: "prohibited", slack: "prohibited" });
 	return dispositions();
 }

package/src/sdk/session.ts

@@ -21,6 +21,7 @@ import {
 	type ToolResultMessage,
 } from "@gajae-code/ai";
 import {
+	codexToolWireName,
 	getOpenAICodexTransportDetails,
 	prewarmOpenAICodexResponses,
 } from "@gajae-code/ai/providers/openai-codex-responses";
@@ -168,6 +169,7 @@ import { buildNamedToolChoice, buildNamedToolChoiceResult } from "../utils/tool-
 import { buildWorkspaceTree, type WorkspaceTree } from "../workspace-tree";
 import {
 	attachLifecycleStartupCapability,
+	lifecycleMcpStartupTimeoutOption,
 	lifecycleStartupCapabilityOption,
 	type SdkStartupCapability,
 } from "./startup-capability";
@@ -1028,6 +1030,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const lifecycleStartupCapability = (
 		options as CreateAgentSessionOptions & { [lifecycleStartupCapabilityOption]?: SdkStartupCapability }
 	)[lifecycleStartupCapabilityOption];
+	// ACP lifecycle launches carry their own MCP startup budget; every other
+	// consumer keeps the manager's short default ceiling.
+	const lifecycleMcpStartupTimeoutMs = (
+		options as CreateAgentSessionOptions & { [lifecycleMcpStartupTimeoutOption]?: number }
+	)[lifecycleMcpStartupTimeoutOption];
 	const isCanonicalSubSession =
 		(options.taskDepth ?? 0) > 0 || Boolean(options.parentTaskPrefix) || Boolean(options.currentAgentType);
 	if (isCanonicalSubSession && options.mcpConfigPath !== undefined) {
@@ -1720,7 +1727,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 		const preExactCustomToolNames = customTools.map(tool => tool.name);
 		if (explicitMcpConfigPath !== undefined) {
-			const owned = new MCPManager(cwd, null, { toolsOnly: true });
+			const owned = new MCPManager(cwd, null, {
+				toolsOnly: true,
+				...(lifecycleMcpStartupTimeoutMs !== undefined
+					? { maxStartupTimeoutMs: lifecycleMcpStartupTimeoutMs }
+					: {}),
+			});
 			owned.setAuthStorage(authStorage);
 			mcpManager = owned;
 			ownsMcpManager = true;
@@ -2177,7 +2189,18 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				const previousPromptMetadataModel = promptMetadataModel;
 				promptMetadataModel = candidateModel;
 				try {
-					return buildSystemPromptToolMetadata(tools);
+					const activeModel = candidateModel ?? agent?.state.model ?? model;
+					// Codex renames reserved tool names on the wire; the prompt must
+					// refer to the tools by the names the model actually receives.
+					const overrides =
+						activeModel?.api === "openai-codex-responses"
+							? Object.fromEntries(
+									Array.from(tools.keys())
+										.filter(name => codexToolWireName(name) !== name)
+										.map(name => [name, { wireName: codexToolWireName(name) }]),
+								)
+							: {};
+					return buildSystemPromptToolMetadata(tools, overrides);
 				} finally {
 					promptMetadataModel = previousPromptMetadataModel;
 				}

package/src/sdk/startup-capability.ts

@@ -22,6 +22,12 @@ const MAX_MESSAGE_BYTES = 512;
 
 /** Internal symbols for lifecycle-only SDK startup construction and bus wiring. */
 export const lifecycleStartupCapabilityOption: unique symbol = Symbol("lifecycleStartupCapability");
+/**
+ * Internal option carrying the startup budget for ACP lifecycle MCP launches.
+ * Only set when the lifecycle request actually supplies `mcpServers`, so the
+ * longer ceiling never leaks to ordinary CLI/SDK `mcpConfigPath` consumers.
+ */
+export const lifecycleMcpStartupTimeoutOption: unique symbol = Symbol("lifecycleMcpStartupTimeout");
 const lifecycleStartupCapabilityOnApi: unique symbol = Symbol("lifecycleStartupCapabilityOnApi");
 
 export function attachLifecycleStartupCapability(api: object, capability: SdkStartupCapability): void {