@makaio/adapter-codex-app-server 1.0.0-dev-1779051654000

package/dist/index.mjs

@@ -0,0 +1,3787 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import { AIAdapter, AIAgent, AIAgentConnector, BaseConnectorTurn, UserMessageQueue, createAdapterNamespace, extractMcpCallTarget, formatContextBlocksAsText, formatMessageHistoryAsTranscript, isMcpCallTool, resolveConformanceTestPreset, resolveDisabledNativeTools, resolveTestConfig, serializeBlockToText, serializeTurnContext } from "@makaio/framework/adapters";
+import { z } from "zod";
+import { AgentSubjects, ClientSubjects, ToolSubjects } from "@makaio/framework/contracts";
+import { MakaioBus } from "@makaio/framework/bus";
+import { buildClientSessionBase, emitBestEffort } from "@makaio/framework/clients";
+import { filterToolsWithSchema, loadToolsFromRegistry } from "@makaio/framework/adapters/stream-session";
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+import { createAdapterConfigFactory, resolveSessionEnvironment } from "@makaio/framework/adapters/config";
+
+//#region src/namespaces/schemas/thread-lifecycle.ts
+/**
+* Schema for thread.started event
+* Emitted when a new thread is successfully started.
+*
+* Note: agentId is required for bus filtering to work correctly.
+* The filteredBus.on() filters events by agentId.
+*/
+const ThreadStartedSchema = z.object({
+	agentId: z.string(),
+	threadId: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for thread.completed event
+* Emitted when a thread is archived or completed.
+*
+* Note: agentId is required for bus filtering to work correctly.
+*/
+const ThreadCompletedSchema = z.object({
+	agentId: z.string(),
+	threadId: z.string(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/turn-lifecycle.ts
+/**
+* Turn state for Codex App-Server connector.
+*
+* State machine follows the app-server protocol:
+* - idle → active (turn/start request sent)
+* - active → processing_started (turn/started notification received)
+* - processing_started → turn_started (first item/started notification)
+* - turn_started → step_started (command/file item starts)
+* - step_started → step_finished (item completes)
+* - step_finished → turn_finished (turn/completed received)
+* - turn_finished → idle (cleanup, ready for next turn)
+*
+* Immediate mode: active → interrupted → idle (cancelled, new turn with merged content)
+*/
+const CodexAppServerTurnStateSchema = z.enum([
+	"idle",
+	"active",
+	"processing_started",
+	"turn_started",
+	"step_started",
+	"step_finished",
+	"turn_finished",
+	"interrupted"
+]);
+/**
+* Turn state change event
+* Emitted whenever turn state transitions
+*/
+const TurnStateChangedSchema = z.object({
+	adapterId: z.string(),
+	agentId: z.string(),
+	oldState: CodexAppServerTurnStateSchema,
+	newState: CodexAppServerTurnStateSchema,
+	timestamp: z.number()
+});
+/**
+* Schema for turn.started event
+* Emitted when a turn begins processing (turn_started state).
+*
+* Note: agentId is required for bus filtering to work correctly.
+*/
+const TurnStartedSchema = z.object({
+	agentId: z.string(),
+	threadId: z.string(),
+	turnId: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for turn.completed event
+* Emitted when a turn completes (turn_finished state).
+*
+* Note: agentId is required for bus filtering to work correctly.
+*/
+const TurnCompletedSchema = z.object({
+	agentId: z.string(),
+	threadId: z.string(),
+	turnId: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for turn.step_started event
+* Emitted when a step/item begins execution.
+*
+* Note: agentId is required for bus filtering to work correctly.
+*/
+const TurnStepStartedSchema = z.object({
+	agentId: z.string(),
+	threadId: z.string(),
+	turnId: z.string(),
+	itemId: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for turn.step_finished event
+* Emitted when a step/item completes.
+*
+* Note: agentId is required for bus filtering to work correctly.
+*/
+const TurnStepFinishedSchema = z.object({
+	agentId: z.string(),
+	threadId: z.string(),
+	turnId: z.string(),
+	itemId: z.string(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/item-lifecycle.ts
+/**
+* Schema for item.started event
+* Emitted when an item begins execution
+*/
+const ItemStartedSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	itemId: z.string(),
+	itemType: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for item.completed event
+* Emitted when an item completes
+*/
+const ItemCompletedSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	itemId: z.string(),
+	itemType: z.string(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/agent-message.ts
+/**
+* Schema for agent_message.delta event
+* Emitted for incremental text updates from the agent
+*/
+const AgentMessageDeltaSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	delta: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for agent_message event
+* Emitted when a complete agent message is ready
+*/
+const AgentMessageSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	message: z.string(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/shared.ts
+/**
+* Enrichment fields auto-injected by requestToolApproval.
+* These are added by the connector's base class, not passed by the caller.
+*
+* Shared across command-execution and file-change approval schemas.
+*/
+const EnrichmentFieldsSchema = z.object({
+	agentId: z.string().optional(),
+	adapterId: z.string().optional(),
+	adapterName: z.string().optional(),
+	adapterSessionId: z.string().optional()
+});
+/**
+* Shared response schema for approval RPCs (exec and file-change).
+*
+* Both command execution and file change approval return
+* the same accept/decline decision format.
+*/
+const ApprovalResponseSchema = z.object({
+	decision: z.enum(["accept", "decline"]),
+	message: z.string().optional()
+});
+
+//#endregion
+//#region src/namespaces/schemas/command-execution.ts
+/**
+* Schema for exec_command.begin event
+* Emitted when a command execution starts
+*/
+const ExecCommandBeginSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	callId: z.string(),
+	command: z.array(z.string()),
+	cwd: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for exec_approval_request RPC
+* Request/response pair for command approval routing via scoped bus.
+* Connector calls requestToolApproval → registerToolApprovalHandler routes to global bus → returns response.
+*
+* Note: Enrichment fields (agentId, adapterId, etc.) are auto-injected by requestToolApproval.
+*/
+const ExecApprovalRequestSchema = {
+	request: z.object({
+		threadId: z.string(),
+		turnId: z.string(),
+		callId: z.string(),
+		command: z.array(z.string()),
+		cwd: z.string(),
+		reason: z.string().nullable(),
+		timestamp: z.number()
+	}).merge(EnrichmentFieldsSchema),
+	response: ApprovalResponseSchema
+};
+/**
+* Schema for exec_command.output.delta event
+* Emitted for incremental output from a running command
+*/
+const ExecCommandOutputDeltaSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	callId: z.string(),
+	stream: z.enum(["stdout", "stderr"]),
+	chunk: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for exec_command.end event
+* Emitted when a command execution completes
+*/
+const ExecCommandEndSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	callId: z.string(),
+	exitCode: z.number(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/file-change.ts
+/**
+* Schema for file_change_approval_request RPC
+* Request/response pair for file change approval routing via scoped bus.
+* Connector calls requestToolApproval → registerToolApprovalHandler routes to global bus → returns response.
+*
+* Note: Enrichment fields (agentId, adapterId, etc.) are auto-injected by requestToolApproval.
+*/
+const FileChangeApprovalRequestSchema = {
+	request: z.object({
+		threadId: z.string(),
+		turnId: z.string(),
+		itemId: z.string(),
+		reason: z.string().nullable(),
+		grantRoot: z.string().nullable(),
+		timestamp: z.number()
+	}).merge(EnrichmentFieldsSchema),
+	response: ApprovalResponseSchema
+};
+/**
+* Schema for file_change.output.delta event
+* Emitted for incremental file change updates
+*/
+const FileChangeOutputDeltaSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	itemId: z.string(),
+	delta: z.string(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/reasoning.ts
+/**
+* Schema for reasoning.delta event
+* Emitted for incremental reasoning content
+*/
+const ReasoningDeltaSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	delta: z.string(),
+	timestamp: z.number()
+});
+/**
+* Schema for reasoning event
+* Emitted when complete reasoning is available
+*/
+const ReasoningSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	reasoning: z.string(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/token-usage.ts
+/**
+* Schema for token_usage event
+* Emitted when token usage is updated.
+*
+* Note: agentId is required for bus filtering to work correctly.
+*/
+const TokenUsageSchema = z.object({
+	agentId: z.string(),
+	threadId: z.string(),
+	turnId: z.string().optional(),
+	promptTokens: z.number(),
+	inputCachedTokens: z.number().default(0),
+	completionTokens: z.number(),
+	reasoningTokens: z.number().default(0),
+	totalTokens: z.number(),
+	modelContextWindow: z.number().optional(),
+	timestamp: z.number()
+});
+
+//#endregion
+//#region src/namespaces/schemas/dynamic-tool-call.ts
+/**
+* Schema for dynamic_tool_call_begin event.
+*
+* Emitted when an `item/started` notification arrives for a `dynamicToolCall` item.
+* The `name` and `args` fields are populated from the cached `item/tool/call` server
+* request that was handled before (or concurrent with) the `item/started` notification.
+*/
+const DynamicToolCallBeginSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	/** Item ID — same as `toolCallId` used in `item/tool/call` */
+	itemId: z.string(),
+	/** Tool name as declared in `dynamicTools` at `thread/start` */
+	name: z.string(),
+	/** Tool input arguments */
+	args: z.record(z.string(), z.unknown()),
+	timestamp: z.number()
+});
+/**
+* Schema for dynamic_tool_call_end event.
+*
+* Emitted when an `item/completed` notification arrives for a `dynamicToolCall` item.
+* The `output` and `success` fields are populated from the cached tool execution result.
+*/
+const DynamicToolCallEndSchema = z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	/** Item ID — same as `toolCallId` used in `item/tool/call` */
+	itemId: z.string(),
+	/** Tool name as declared in `dynamicTools` at `thread/start` */
+	name: z.string(),
+	/** Serialised tool output */
+	output: z.string(),
+	/** Whether execution succeeded (false if the result contained an `error` key) */
+	success: z.boolean(),
+	timestamp: z.number()
+});
+/**
+* Schema for dynamic_tool_call_approval_request RPC.
+*
+* Request/response pair for dynamic tool call approval routing via scoped bus.
+* Connector calls requestToolApproval → approval handler routes to global bus → returns response.
+*
+* Note: Enrichment fields (agentId, adapterId, etc.) are auto-injected by requestToolApproval.
+*/
+const DynamicToolCallApprovalRequestSchema = {
+	request: z.object({
+		threadId: z.string(),
+		turnId: z.string(),
+		/** Item ID — same as `toolCallId` used in `item/tool/call` */
+		itemId: z.string(),
+		/** Tool name as declared in `dynamicTools` at `thread/start` */
+		name: z.string(),
+		/** Tool input arguments */
+		args: z.record(z.string(), z.unknown()),
+		timestamp: z.number()
+	}).merge(EnrichmentFieldsSchema),
+	response: ApprovalResponseSchema
+};
+
+//#endregion
+//#region src/namespaces/index.ts
+/**
+* Codex App-Server Adapter Namespace
+*
+* Defines internal bus events for the codex app-server adapter.
+* These events are emitted by the adapter and consumed by the core system.
+*/
+const namespace = "adapter:codex-app-server";
+/**
+* Codex App-Server Adapter schemas.
+* Extracted as const to enable FilterPayload type computation via typeof.
+*/
+const codexAppServerSchemas = {
+	thread_started: ThreadStartedSchema,
+	thread_completed: ThreadCompletedSchema,
+	turn_state_changed: TurnStateChangedSchema,
+	turn_started: TurnStartedSchema,
+	turn_completed: TurnCompletedSchema,
+	turn_step_started: TurnStepStartedSchema,
+	turn_step_finished: TurnStepFinishedSchema,
+	item_started: ItemStartedSchema,
+	item_completed: ItemCompletedSchema,
+	agent_message_delta: AgentMessageDeltaSchema,
+	agent_message: AgentMessageSchema,
+	exec_command_begin: ExecCommandBeginSchema,
+	exec_approval_request: ExecApprovalRequestSchema,
+	exec_command_output_delta: ExecCommandOutputDeltaSchema,
+	exec_command_end: ExecCommandEndSchema,
+	file_change_approval_request: FileChangeApprovalRequestSchema,
+	file_change_output_delta: FileChangeOutputDeltaSchema,
+	reasoning_delta: ReasoningDeltaSchema,
+	reasoning: ReasoningSchema,
+	token_usage: TokenUsageSchema,
+	dynamic_tool_call_begin: DynamicToolCallBeginSchema,
+	dynamic_tool_call_end: DynamicToolCallEndSchema,
+	dynamic_tool_call_approval_request: DynamicToolCallApprovalRequestSchema
+};
+/**
+* Codex App-Server Adapter Namespace
+*
+* Defines the event subjects and schemas for internal bus communication
+* between the codex app-server adapter and the core system.
+*/
+const CodexAppServerNamespace = createAdapterNamespace(namespace, codexAppServerSchemas);
+/**
+* Typed subject literals for Codex App-Server adapter.
+* Use these constants to subscribe to specific message types with full type safety.
+*/
+const CodexAppServerSubjects = CodexAppServerNamespace.subjects;
+
+//#endregion
+//#region src/tool-handling.ts
+const TOOL_APPROVAL_DEBUG_ENABLED = process.env.MAKAIO_DEBUG_TOOL_APPROVAL === "1" || process.env.DEBUG?.includes("codex-tool-approval") === true;
+/**
+* Debug logger for tool-approval bridge flow.
+* @param message - Message to log
+* @param context - Optional structured context
+*/
+function logToolApprovalDebug(message, context) {
+	if (!TOOL_APPROVAL_DEBUG_ENABLED) return;
+	console.debug("[registerToolApprovalHandler]", message, context ?? {});
+}
+/**
+* Build the shared approval envelope fields from adapter context.
+* @param context - Adapter context
+* @returns Shared approval envelope fields
+*/
+function createApprovalEnvelope(context) {
+	return {
+		adapterId: context.adapterId,
+		adapterName: context.adapterName,
+		agentId: context.agentId,
+		adapterSessionId: context.adapterSessionId,
+		sessionId: context.sessionId
+	};
+}
+/**
+* Transform command execution approval request → AgentToolApproveRequest.
+*
+* Converts the app-server's command execution approval params into the global
+* tool approval request format. The params are included as args for context.
+* @param params - Raw app-server approval request parameters
+* @param context - Adapter context for request enrichment
+* @returns Global tool approval request
+*/
+function toGlobalToolApproval(params, context) {
+	return {
+		...createApprovalEnvelope(context),
+		toolCallId: params.itemId,
+		toolName: "bash",
+		reasoning: params.reason ?? void 0,
+		args: {
+			threadId: params.threadId,
+			turnId: params.turnId,
+			itemId: params.itemId,
+			reason: params.reason,
+			proposedExecpolicyAmendment: params.proposedExecpolicyAmendment
+		}
+	};
+}
+/**
+* Transform file change approval request → AgentToolApproveRequest.
+*
+* Converts the app-server's file change approval params into the global
+* tool approval request format. The params are included as args for context.
+* @param params - Raw app-server approval request parameters
+* @param context - Adapter context for request enrichment
+* @returns Global tool approval request
+*/
+function toGlobalFileApproval(params, context) {
+	return {
+		...createApprovalEnvelope(context),
+		toolCallId: params.itemId,
+		toolName: "patch",
+		reasoning: params.reason ?? void 0,
+		args: {
+			threadId: params.threadId,
+			turnId: params.turnId,
+			itemId: params.itemId,
+			reason: params.reason,
+			grantRoot: params.grantRoot
+		}
+	};
+}
+/**
+* Transform AgentToolApproveResponse → app-server decision format.
+*
+* Converts the global approval response into the simple accept/decline format
+* expected by the codex app-server protocol.
+* @param response - Global tool approval response
+* @returns App-server approval decision with optional message
+*/
+function fromGlobalToolApproval(response) {
+	if (response.action === "allow") return { decision: "accept" };
+	return {
+		decision: "decline",
+		message: response.message || void 0
+	};
+}
+/**
+* Register tool approval handler that bridges connector's approval requests
+* to the global AgentSubjects.toolApprove bus.
+*
+* Wires:
+* - CodexAppServerSubjects.exec_approval_request → AgentSubjects.toolApprove
+* - CodexAppServerSubjects.file_change_approval_request → AgentSubjects.toolApprove
+*
+* Used by both createTestConfig (test harness) and agent.ts (production).
+* @param connector - Connector for Codex App-Server adapter (needs `on` and `getTimeoutMs` methods)
+* @param context - Adapter context (can be lazy callback)
+* @returns Unsubscribe function that removes both handlers
+*/
+function registerToolApprovalHandler(connector, context) {
+	const timeout = connector.getTimeoutMs("toolApproval");
+	/**
+	* Resolve adapter context lazily (callback avoids race condition with adapterSessionId)
+	* @returns Resolved ToolApprovalContext
+	*/
+	const resolveContext = async () => {
+		const providedContext = typeof context === "function" ? await context() : context;
+		if (providedContext == null || typeof providedContext !== "object" || typeof providedContext.sessionId !== "string") throw new Error("Tool approval requires a sessionId — ensure the agent was created within a session");
+		const sessionId = providedContext.sessionId.trim();
+		if (sessionId === "") throw new Error("Tool approval requires a sessionId — ensure the agent was created within a session");
+		return {
+			adapterId: providedContext?.adapterId ?? connector.adapterId,
+			adapterName: providedContext?.adapterName ?? connector.getAdapterName(),
+			agentId: providedContext?.agentId ?? connector.getAgentId(),
+			adapterSessionId: providedContext?.adapterSessionId ?? await connector.getAdapterSessionId(),
+			sessionId
+		};
+	};
+	/**
+	* Bridge a connector approval request to the global approval bus.
+	* @param ctx - Connector request context
+	* @param transform - Payload-to-global-request transformer
+	* @param logTag - Optional debug label
+	*/
+	const handleApprovalRequest = async (ctx, transform, logTag) => {
+		if (logTag) logToolApprovalDebug(`${logTag} invoked`, { timestamp: Date.now() });
+		let globalResponse;
+		try {
+			const resolvedContext = await resolveContext();
+			if (logTag) logToolApprovalDebug("resolved context", {
+				agentId: resolvedContext.agentId,
+				timestamp: Date.now()
+			});
+			const request = transform(ctx.payload, resolvedContext);
+			if (logTag) logToolApprovalDebug("requesting global approval", {
+				agentId: request.agentId,
+				timestamp: Date.now()
+			});
+			globalResponse = await MakaioBus.request(AgentSubjects.toolApprove, request, { timeout });
+		} catch (error) {
+			console.error("[registerToolApprovalHandler] Tool approval request failed:", error);
+			const errorDetails = error instanceof Error ? `: ${error.message}` : "";
+			ctx.setResult({
+				decision: "decline",
+				message: `Tool approval request failed${errorDetails}`
+			});
+			return;
+		}
+		if (logTag) logToolApprovalDebug("received global approval response", {
+			action: globalResponse.action,
+			timestamp: Date.now()
+		});
+		if (globalResponse.action === "deny" && globalResponse.shouldAbort) throw new Error(`Tool use denied by approval handler: ${globalResponse.message ?? "access denied"}`);
+		ctx.setResult(fromGlobalToolApproval(globalResponse));
+	};
+	const unsubExec = connector.on(CodexAppServerSubjects.exec_approval_request, async (ctx) => {
+		await handleApprovalRequest(ctx, toGlobalToolApprovalFromInternal, "exec_approval_request");
+	});
+	const unsubFile = connector.on(CodexAppServerSubjects.file_change_approval_request, async (ctx) => {
+		await handleApprovalRequest(ctx, toGlobalFileApprovalFromInternal, "file_change_approval_request");
+	});
+	return () => {
+		unsubExec();
+		unsubFile();
+	};
+}
+/**
+* Transform internal scoped bus exec approval payload → AgentToolApproveRequest.
+*
+* Similar to toGlobalToolApproval but works with the internal scoped bus payload
+* which has a slightly different shape (callId vs itemId).
+* @param payload - Internal scoped bus payload with threadId, turnId, callId, command, cwd
+* @param context - Adapter context for request enrichment
+* @returns Global tool approval request
+*/
+function toGlobalToolApprovalFromInternal(payload, context) {
+	return {
+		...createApprovalEnvelope(context),
+		toolCallId: payload.callId,
+		toolName: "bash",
+		reasoning: payload.reason ?? void 0,
+		args: {
+			threadId: payload.threadId,
+			turnId: payload.turnId,
+			callId: payload.callId,
+			command: payload.command,
+			cwd: payload.cwd,
+			reason: payload.reason
+		}
+	};
+}
+/**
+* Transform internal scoped bus file approval payload → AgentToolApproveRequest.
+*
+* Similar to toGlobalFileApproval but works with the internal scoped bus payload
+* which has a slightly different shape (itemId vs callId).
+* @param payload - Internal scoped bus payload with threadId, turnId, itemId, reason, grantRoot
+* @param context - Adapter context for request enrichment
+* @returns Global tool approval request
+*/
+function toGlobalFileApprovalFromInternal(payload, context) {
+	return {
+		...createApprovalEnvelope(context),
+		toolCallId: payload.itemId,
+		toolName: "patch",
+		reasoning: payload.reason ?? void 0,
+		args: {
+			threadId: payload.threadId,
+			turnId: payload.turnId,
+			itemId: payload.itemId,
+			reason: payload.reason,
+			grantRoot: payload.grantRoot
+		}
+	};
+}
+
+//#endregion
+//#region src/agent.ts
+/**
+* Codex App-Server Agent - Event routing layer.
+*
+* Wires connector events to global agent.* subjects.
+* Auto-enriches payloads with AgentContext via emitGlobal().
+*
+* Responsibilities:
+* 1. Wire connector's scoped bus events to global agent.* subjects
+* 2. Auto-enrich payloads with AgentContext
+* 3. Track usage metrics
+* 4. Route tool approval to global bus
+* 5. Emit normalized client.session.* observed-semantics events
+* 6. Emit client.runtime.observe (best-effort) when a thread starts with a confirmed adapter session ID
+*
+* Event Flow:
+* - CodexAppServerConnector emits to adapter:codex-app-server:* subjects
+* - CodexAppServerAgent routes to semantic subjects via wireConnectorEvents()
+* - CodexAppServerAgent subscribes to semantic subjects and emits to global bus (agent.*)
+* - Downstream consumers subscribe to normalized agent.* subjects
+* @packageDocumentation
+*/
+/**
+* Maximum number of characters retained in `toolOutputCache` per tool call.
+*
+* Streaming consumers already receive every chunk via
+* `AgentSubjects.tool.output`, so the cache is only needed to populate the
+* final `tool_output` content block in `emitToolStepFinished`. Capping it
+* prevents unbounded memory growth for long-running commands (builds, test
+* suites, etc.) whose output can otherwise reach tens of megabytes.
+*/
+const MAX_TOOL_OUTPUT_CACHE_CHARS = 256 * 1024;
+/**
+* Keep the newest tool output in the bounded per-tool cache.
+*
+* Streaming consumers receive every chunk via `AgentSubjects.tool.output`; the
+* cache is only the final content-block snapshot, so retaining the tail keeps
+* the diagnostic context where command failures usually appear.
+* @param output - Full accumulated output candidate
+* @returns Output capped to the configured character count
+*/
+function capToolOutputCache(output) {
+	return output.length > MAX_TOOL_OUTPUT_CACHE_CHARS ? output.slice(-MAX_TOOL_OUTPUT_CACHE_CHARS) : output;
+}
+/**
+* Codex App-Server Agent - Middle layer between AIAdapter and CodexAppServerConnector.
+*
+* Responsibilities:
+* 1. Wire connector's scoped bus events to global agent.* subjects
+* 2. Auto-enrich payloads with AgentContext via emitGlobal()
+* 3. Emit normalized client.session.* observed-semantics events (best-effort)
+* 4. Emit client.runtime.observe (best-effort) when a thread starts with a confirmed adapter session ID
+*
+* Event Flow:
+* - CodexAppServerConnector emits to adapter:codex-app-server:* subjects
+* - CodexAppServerAgent routes to semantic subjects via wireConnectorEvents()
+* - CodexAppServerAgent subscribes to semantic subjects and emits to global bus (agent.*)
+* - Downstream consumers subscribe to normalized agent.* subjects
+*/
+var CodexAppServerAgent = class extends AIAgent {
+	/** Cache of tool call arguments indexed by callId for content blocks */
+	toolCallCache = /* @__PURE__ */ new Map();
+	/** Accumulated tool output indexed by callId during streaming */
+	toolOutputCache = /* @__PURE__ */ new Map();
+	/** Track toolCallId to blockIndex for correlation between step.started and step.finished */
+	toolBlockIndexMap = /* @__PURE__ */ new Map();
+	/**
+	* Guard: client.session.* global bus observations are wired once per agent
+	* lifetime (not per connector swap). Connector-level wiring uses
+	* addConnectorWiringCleanup(); these stable global subscriptions use
+	* addBusHandlerCleanup() and must not accumulate across swaps.
+	*/
+	clientSessionObservationsWired = false;
+	wireEvents(connector) {
+		this.wireConnectorEvents(connector);
+		this.wireToolApprovalRpc(connector);
+		this.wireClientSessionTurnObservations();
+	}
+	/**
+	* Wire connector's bus events to global agent.* subjects.
+	*
+	* Maps CodexAppServerSubjects.* to AgentSubjects.*
+	*
+	* Note: Turn lifecycle events (turn.started, turn.completed) are NOT wired here
+	* because the base AIAgent's message-lifecycle-tracker already handles emitting
+	* these global events when messages are acknowledged and turns complete.
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireConnectorEvents(connector) {
+		this.wireThreadLifecycleEvents(connector);
+		this.wireMessageEvents(connector);
+		this.wireToolEvents(connector);
+		this.wireUsageTracking(connector);
+	}
+	/**
+	* Build the shared base payload for all `client.session.*` observed-semantics
+	* events by forwarding this agent's current identity fields to the shared
+	* {@link buildClientSessionBase} helper.
+	*
+	* Captures the adapter session ID best-effort: if the connector has not yet
+	* confirmed a session ID (e.g., very early in initialization), the field is
+	* omitted rather than blocking emission.
+	* @returns Base payload with clientId, source, observedAt, and optional session IDs
+	*/
+	getClientSessionBase() {
+		return buildClientSessionBase({
+			clientId: this.config.clientId ?? "codex",
+			sessionId: this.sessionId,
+			adapterSessionId: this.connector?.adapterSessionId
+		});
+	}
+	/**
+	* Wire stable global bus subscriptions for client.session.turn.* events.
+	*
+	* Uses addBusHandlerCleanup() so these subscriptions survive connector swaps.
+	* Guarded by clientSessionObservationsWired so they are registered exactly once
+	* per agent lifetime regardless of how many connector swaps occur.
+	*
+	* Subscribes to:
+	* - AgentSubjects.turn.started → client.session.turn.started
+	* - AgentSubjects.turn.completed → client.session.turn.completed
+	* - AgentSubjects.user_message.sent → client.session.userPrompt.submitted
+	*/
+	wireClientSessionTurnObservations() {
+		if (this.clientSessionObservationsWired) return;
+		this.clientSessionObservationsWired = true;
+		const filteredBus = this.globalBus.withFilter({ agentId: this.agentId });
+		this.addBusHandlerCleanup(filteredBus.on(AgentSubjects.turn.started, () => {
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.turn.started, this.getClientSessionBase());
+			});
+		}));
+		this.addBusHandlerCleanup(filteredBus.on(AgentSubjects.turn.completed, () => {
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.turn.completed, this.getClientSessionBase());
+			});
+		}));
+		this.addBusHandlerCleanup(filteredBus.on(AgentSubjects.user_message.sent, (ctx) => {
+			const prompt = ctx.payload.content.message;
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.userPrompt.submitted, {
+					...this.getClientSessionBase(),
+					...prompt !== void 0 && { prompt }
+				});
+			});
+		}));
+	}
+	/**
+	* Wire thread lifecycle events.
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireThreadLifecycleEvents(connector) {
+		this.subscribeConnector(connector, CodexAppServerSubjects.thread_started, async () => {
+			this.toolCallCache.clear();
+			this.toolOutputCache.clear();
+			this.toolBlockIndexMap.clear();
+			await this.emitStart();
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.started, this.getClientSessionBase());
+			});
+			const adapterSessionId = this.connector?.adapterSessionId;
+			if (adapterSessionId) this.globalBus.requestOptional(ClientSubjects.runtime.observe, {
+				clientId: this.config.clientId ?? "codex",
+				source: {
+					layer: "adapter",
+					producer: "codex-app-server"
+				},
+				observedAt: Date.now(),
+				adapterSessionId,
+				sessionId: this.sessionId
+			}).catch(() => {});
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.thread_completed, async () => {
+			const messageId = crypto.randomUUID();
+			return this.emitCompletion({ messageId });
+		});
+	}
+	/**
+	* Wire assistant message events.
+	*
+	* Note: Turn lifecycle events (agent.turn.started, agent.turn.completed) are emitted by
+	* MessageLifecycleTracker in ai-adapters-core based on message handle states,
+	* not by adapter-specific events.
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireMessageEvents(connector) {
+		this.subscribeConnector(connector, CodexAppServerSubjects.agent_message_delta, async (ctx) => {
+			await this.emitGlobal(AgentSubjects.message_delta, { text: ctx.payload.delta });
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.agent_message, async (ctx) => {
+			await this.emitGlobal(AgentSubjects.message, { content: ctx.payload.message });
+			await this.emitStepStarted("text");
+			await this.emitStepFinished("text", {
+				type: "text",
+				content: ctx.payload.message
+			});
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.reasoning_delta, async (ctx) => {
+			await this.emitGlobal(AgentSubjects.reasoning_delta, { content: ctx.payload.delta });
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.reasoning, async (ctx) => {
+			await this.emitGlobal(AgentSubjects.reasoning, { content: ctx.payload.reasoning });
+			await this.emitStepStarted("reasoning");
+			await this.emitStepFinished("reasoning", {
+				type: "reasoning",
+				content: ctx.payload.reasoning
+			});
+		});
+	}
+	/**
+	* Wire tool-related events.
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireToolEvents(connector) {
+		this.wireCommandExecutionEvents(connector);
+		this.wireFileChangeEvents(connector);
+		this.wireDynamicToolCallEvents(connector);
+	}
+	/**
+	* Wire command execution events (bash tool).
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireCommandExecutionEvents(connector) {
+		this.subscribeConnector(connector, CodexAppServerSubjects.exec_approval_request, async (ctx) => {
+			const payload = ctx.payload;
+			this.toolCallCache.set(payload.callId, {
+				command: payload.command,
+				cwd: payload.cwd,
+				toolCallId: payload.callId,
+				name: "bash",
+				args: {
+					command: payload.command,
+					cwd: payload.cwd
+				}
+			});
+			await this.emitGlobal(AgentSubjects.tool.use, {
+				toolName: "bash",
+				args: {
+					command: payload.command,
+					cwd: payload.cwd
+				},
+				toolCallId: payload.callId
+			});
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.exec_command_begin, async (ctx) => {
+			await this.handleExecCommandBegin(ctx.payload);
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.exec_command_output_delta, async (ctx) => {
+			const payload = ctx.payload;
+			const appended = (this.toolOutputCache.get(payload.callId) ?? "") + payload.chunk;
+			this.toolOutputCache.set(payload.callId, capToolOutputCache(appended));
+			await this.emitGlobal(AgentSubjects.tool.output, {
+				output: payload.chunk,
+				toolCallId: payload.callId
+			});
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.exec_command_end, async (ctx) => {
+			const payload = ctx.payload;
+			await this.emitGlobal(AgentSubjects.tool.completed, {
+				toolName: "bash",
+				args: this.toolCallCache.get(payload.callId)?.args,
+				result: { exitCode: payload.exitCode },
+				success: payload.exitCode === 0,
+				toolCallId: payload.callId
+			});
+			await this.emitToolStepFinished(payload.callId, this.toolOutputCache.get(payload.callId) ?? `Command completed with exit code ${payload.exitCode}`, payload.exitCode !== 0);
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.tool.post, {
+					...this.getClientSessionBase(),
+					toolName: "bash",
+					toolCallId: payload.callId,
+					success: payload.exitCode === 0
+				});
+			});
+		});
+	}
+	/**
+	* Handle exec_command_begin: build step.started content, emit step.started,
+	* tool.started, and client.session.tool.pre.
+	* @param payload - The exec_command_begin event payload
+	*/
+	async handleExecCommandBegin(payload) {
+		const cachedTool = this.toolCallCache.get(payload.callId);
+		const toolCallContent = cachedTool ? {
+			type: "tool_call",
+			toolCallId: cachedTool.toolCallId,
+			name: cachedTool.name,
+			args: cachedTool.args
+		} : {
+			type: "tool_call",
+			toolCallId: payload.callId,
+			name: "bash",
+			args: {
+				command: payload.command,
+				cwd: payload.cwd
+			}
+		};
+		const blockIndex = this.getBlockIndex();
+		this.toolBlockIndexMap.set(payload.callId, blockIndex);
+		await this.emitStepStarted("tool_use", {
+			type: "tool_use",
+			toolName: "bash",
+			toolCallId: payload.callId
+		}, toolCallContent);
+		this.incrementBlockIndex();
+		await this.emitGlobal(AgentSubjects.tool.started, {
+			toolName: "bash",
+			toolCallId: payload.callId
+		});
+		emitBestEffort(async () => {
+			await this.globalBus.emit(ClientSubjects.session.tool.pre, {
+				...this.getClientSessionBase(),
+				toolName: "bash",
+				toolCallId: payload.callId
+			});
+		});
+	}
+	/**
+	* Wire file change events (patch tool).
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireFileChangeEvents(connector) {
+		this.subscribeConnector(connector, CodexAppServerSubjects.file_change_approval_request, async (ctx) => {
+			const { itemId, reason, grantRoot } = ctx.payload;
+			const args = {
+				reason,
+				grantRoot
+			};
+			this.toolCallCache.set(itemId, {
+				command: [],
+				cwd: "",
+				toolCallId: itemId,
+				name: "patch",
+				args
+			});
+			await this.emitGlobal(AgentSubjects.tool.use, {
+				toolName: "patch",
+				args,
+				toolCallId: itemId
+			});
+			const blockIndex = this.getBlockIndex();
+			this.toolBlockIndexMap.set(itemId, blockIndex);
+			await this.emitStepStarted("tool_use", {
+				type: "tool_use",
+				toolName: "patch",
+				toolCallId: itemId
+			}, {
+				type: "tool_call",
+				toolCallId: itemId,
+				name: "patch",
+				args
+			});
+			this.incrementBlockIndex();
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.tool.pre, {
+					...this.getClientSessionBase(),
+					toolName: "patch",
+					toolCallId: itemId
+				});
+			});
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.file_change_output_delta, async (ctx) => {
+			const { itemId, delta } = ctx.payload;
+			const appended = (this.toolOutputCache.get(itemId) ?? "") + delta;
+			this.toolOutputCache.set(itemId, capToolOutputCache(appended));
+			await this.emitGlobal(AgentSubjects.tool.output, {
+				output: delta,
+				toolCallId: itemId
+			});
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.item_completed, async (ctx) => {
+			const cached = this.toolCallCache.get(ctx.payload.itemId);
+			if (cached?.name === "patch") {
+				const output = this.toolOutputCache.get(ctx.payload.itemId) ?? "File change applied";
+				await this.emitGlobal(AgentSubjects.tool.completed, {
+					toolName: "patch",
+					args: cached.args,
+					result: { output },
+					success: true,
+					toolCallId: ctx.payload.itemId
+				});
+				await this.emitToolStepFinished(ctx.payload.itemId, output, false);
+				emitBestEffort(async () => {
+					await this.globalBus.emit(ClientSubjects.session.tool.post, {
+						...this.getClientSessionBase(),
+						toolName: "patch",
+						toolCallId: ctx.payload.itemId,
+						success: true
+					});
+				});
+			}
+		});
+	}
+	/**
+	* Wire dynamic tool call events (experimental API).
+	*
+	* Handles registry tools declared in `dynamicTools` at `thread/start`.
+	* The execution happens in the `item/tool/call` server request handler; these
+	* events carry the cached result into the agent's step lifecycle.
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireDynamicToolCallEvents(connector) {
+		this.subscribeConnector(connector, CodexAppServerSubjects.dynamic_tool_call_begin, async (ctx) => {
+			const { itemId, name, args } = ctx.payload;
+			this.toolCallCache.set(itemId, {
+				command: [],
+				cwd: "",
+				toolCallId: itemId,
+				name,
+				args
+			});
+			const blockIndex = this.getBlockIndex();
+			this.toolBlockIndexMap.set(itemId, blockIndex);
+			await this.emitGlobal(AgentSubjects.tool.use, {
+				toolName: name,
+				args,
+				toolCallId: itemId
+			});
+			await this.emitGlobal(AgentSubjects.tool.started, {
+				toolName: name,
+				toolCallId: itemId
+			});
+			await this.emitStepStarted("tool_use", {
+				type: "tool_use",
+				toolName: name,
+				toolCallId: itemId
+			}, {
+				type: "tool_call",
+				toolCallId: itemId,
+				name,
+				args
+			});
+			this.incrementBlockIndex();
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.tool.pre, {
+					...this.getClientSessionBase(),
+					toolName: name,
+					toolCallId: itemId
+				});
+			});
+		});
+		this.subscribeConnector(connector, CodexAppServerSubjects.dynamic_tool_call_end, async (ctx) => {
+			const { itemId, name, output, success } = ctx.payload;
+			const cached = this.toolCallCache.get(itemId);
+			await this.emitGlobal(AgentSubjects.tool.output, {
+				output,
+				toolCallId: itemId
+			});
+			await this.emitGlobal(AgentSubjects.tool.completed, {
+				toolName: name,
+				args: cached?.args,
+				result: { output },
+				success,
+				toolCallId: itemId
+			});
+			await this.emitToolStepFinished(itemId, output, !success);
+			emitBestEffort(async () => {
+				await this.globalBus.emit(ClientSubjects.session.tool.post, {
+					...this.getClientSessionBase(),
+					toolName: name,
+					toolCallId: itemId,
+					success
+				});
+			});
+		});
+	}
+	/**
+	* Wire usage tracking events.
+	* The base AIAgent.trackUsage() handles dual emission to both
+	* AgentSubjects.usage and adapter session usage subjects.
+	* @param connector - The CodexAppServerConnector to wire events from
+	*/
+	wireUsageTracking(connector) {
+		this.subscribeConnector(connector, CodexAppServerSubjects.token_usage, async (ctx) => {
+			const payload = ctx.payload;
+			const normalized = {
+				provider: "openai",
+				inputTokens: payload.promptTokens,
+				inputCachedTokens: payload.inputCachedTokens,
+				outputTokens: payload.completionTokens,
+				reasoningTokens: payload.reasoningTokens,
+				totalTokens: payload.totalTokens,
+				costUnits: payload.totalTokens,
+				costUnitType: "tokens",
+				contextWindow: payload.modelContextWindow
+			};
+			await this.trackUsage(normalized);
+			if (payload.modelContextWindow) await this.emitContextWindowUpdate({
+				currentTokens: payload.totalTokens,
+				maxTokens: payload.modelContextWindow,
+				cachedTokens: payload.inputCachedTokens
+			});
+		});
+	}
+	/**
+	* Wire tool approval RPC from connector's scoped bus to global AgentSubjects.toolApprove.
+	*
+	* Uses centralized tool-handling helper for consistent approval flow.
+	* Note: adapterSessionId may be undefined at wire time — the lazy callback resolves it
+	* at request time via connector.getAdapterSessionId() to avoid the race condition.
+	* sessionId is always set for agents running within a session; asserted here as the
+	* Zod schema on AgentSubjects.toolApprove enforces it at runtime.
+	* @param connector - The CodexAppServerConnector to wire RPC from
+	*/
+	wireToolApprovalRpc(connector) {
+		this.addConnectorWiringCleanup(registerToolApprovalHandler(connector, async () => {
+			if (this.sessionId == null) throw new Error("Agent sessionId is required for tool approval");
+			return {
+				adapterId: this.adapterId,
+				adapterName: this.adapterName,
+				agentId: this.agentId,
+				adapterSessionId: await this.getAdapterSessionId(),
+				sessionId: this.sessionId
+			};
+		}));
+	}
+	/**
+	* Emit tool step.finished and cleanup cached data.
+	* Shared helper for bash and patch tool completion.
+	* @param toolCallId - Tool call identifier
+	* @param output - Tool output content
+	* @param isError - Whether the tool execution failed
+	*/
+	async emitToolStepFinished(toolCallId, output, isError) {
+		const blockIndex = this.toolBlockIndexMap.get(toolCallId);
+		if (blockIndex === void 0) console.warn(`[CodexAdapter] toolCallId ${toolCallId} not found in toolBlockIndexMap - possible state mismatch`);
+		const resolvedBlockIndex = blockIndex ?? -1;
+		this.toolBlockIndexMap.delete(toolCallId);
+		const content = {
+			type: "tool_output",
+			toolCallId,
+			output,
+			isError
+		};
+		await this.emitGlobal(AgentSubjects.step.finished, {
+			stepType: "tool_use",
+			blockIndex: resolvedBlockIndex,
+			content
+		});
+		this.toolCallCache.delete(toolCallId);
+		this.toolOutputCache.delete(toolCallId);
+	}
+};
+
+//#endregion
+//#region src/dynamic-tool-handling.ts
+/**
+* Dynamic tool integration for Codex App Server.
+*
+* Converts Makaio registry tools to Codex's dynamicTools format for
+* `thread/start`, and handles `item/tool/call` server requests by routing
+* execution through the bus.
+* @packageDocumentation
+*/
+/**
+* Type guard for `item/tool/call` server requests.
+*
+* Used to narrow the generic server-request union (which does not yet include
+* `item/tool/call` in the generated types) to the experimental shape.
+* @param request - The raw server request object
+* @returns `true` if the request is an `item/tool/call` request
+*/
+function isDynamicToolCallRequest(request) {
+	return request.method === "item/tool/call";
+}
+/**
+* Convert registry `ToolListItem[]` to Codex dynamic tool format.
+*
+* Filters out tools without an `inputSchema` because the codex protocol
+* requires a JSON Schema for each dynamic tool declaration.
+* @param tools - Tools from `loadToolsFromRegistry`
+* @returns Codex-compatible dynamic tool declarations
+*/
+function toCodexDynamicToolFormat(tools) {
+	return filterToolsWithSchema(tools).map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.inputSchema
+	}));
+}
+/**
+* Fetch registry tools and convert to Codex dynamic tool format.
+*
+* `loadToolsFromRegistry` catches fetch failures internally and returns `[]`,
+* so this function never throws. Callers always receive a (possibly empty) array.
+* @param adapterId - Adapter instance ID for policy filtering
+* @param adapterName - Adapter type name for policy filtering
+* @returns Codex-formatted dynamic tool declarations
+*/
+async function fetchToolsForCodex(adapterId, adapterName) {
+	return toCodexDynamicToolFormat(await loadToolsFromRegistry(adapterId, adapterName));
+}
+/**
+* Determine whether a serialised tool output string represents a success.
+*
+* Returns `false` when the output is valid JSON that contains a top-level `error`
+* key (the shape emitted by {@link handleDynamicToolCall} on bus failure), and
+* `true` in all other cases (including non-JSON output, which is treated as success).
+*
+* Known limitation: a tool that legitimately returns `{ "error": "..." }` as data
+* will be misclassified as failed. This is acceptable because (a) the Codex dynamic
+* tool protocol has no out-of-band success channel, (b) tools should not use
+* "error" as a top-level key for successful results, and (c) the misclassification
+* only affects lifecycle telemetry, not the tool output returned to the agent.
+*
+* **Error format contract:** {@link handleDynamicToolCall} serialises bus errors as
+* `JSON.stringify({ error: message })` (a single top-level `error` string key).
+* This function is coupled to that exact shape — any change to the error format in
+* `handleDynamicToolCall` must be reflected here.
+* @param outputText - Serialised tool output from a `DynamicToolCallResponse`
+* @returns `true` if the output represents a successful execution
+*/
+function isDynamicToolCallSuccess(outputText) {
+	try {
+		return !("error" in JSON.parse(outputText));
+	} catch {
+		return true;
+	}
+}
+/**
+* Handle an `item/tool/call` server request from codex.
+*
+* Routes execution through `ToolSubjects.execute` on the global bus and
+* converts the result to the content-item format codex expects in the response.
+* Both success and failure paths return a valid response — bus errors are
+* serialised as error content rather than rejecting the promise, so codex
+* always receives a well-formed reply.
+* @param params - Tool call parameters from the server request
+* @param context - Execution context for bus routing and attribution
+* @returns Content items to send back to codex
+*/
+async function handleDynamicToolCall(params, context) {
+	try {
+		const result = await MakaioBus.request(ToolSubjects.execute, {
+			toolName: params.name,
+			input: params.arguments,
+			adapterId: context.adapterId,
+			adapterName: context.adapterName,
+			contextOverrides: {
+				sessionId: context.sessionId,
+				agentId: context.agentId,
+				toolCallId: params.itemId
+			}
+		});
+		const text = result.success ? typeof result.data === "string" ? result.data : JSON.stringify(result.data ?? null) : JSON.stringify({
+			error: result.error.message,
+			code: result.error.code
+		});
+		if (result.success && context.toolLedger && isMcpCallTool(params.name)) {
+			const targetTool = extractMcpCallTarget(params.arguments);
+			if (targetTool !== void 0 && context.currentTurnNumber > 0) context.toolLedger.recordCall(targetTool, context.currentTurnNumber);
+		}
+		return { content: [{
+			type: "text",
+			text
+		}] };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({ error: message })
+		}] };
+	}
+}
+
+//#endregion
+//#region src/connector/approval-handlers.ts
+/**
+* Handle command approval request.
+*
+* Returns an immediate `decline` when the `bash` native tool is disabled by the
+* active harness, bypassing the normal approval flow.
+* Otherwise routes the JSON-RPC server request to the scoped bus via requestToolApproval.
+* @param request - Server request for command approval
+* @param ctx - Approval context
+* @returns Approval response with decision and optional message
+*/
+async function handleCommandApprovalRequest(request, ctx) {
+	if (ctx.getDisabledNativeTools().has("bash")) return {
+		decision: "decline",
+		message: "bash tool is disabled by the active harness"
+	};
+	const params = request.params;
+	try {
+		const commandInfo = ctx.commandExecutionByItemId.get(params.itemId) ?? await ctx.waitForCommandInfo(params.itemId);
+		return await ctx.requestToolApproval(CodexAppServerSubjects.exec_approval_request, {
+			threadId: params.threadId,
+			turnId: params.turnId,
+			callId: params.itemId,
+			command: commandInfo ? [commandInfo.command] : ["<unknown>"],
+			cwd: commandInfo?.cwd ?? ctx.cwd ?? "",
+			timestamp: Date.now(),
+			reason: params.reason ?? null
+		});
+	} catch (error) {
+		ctx.handleError(/* @__PURE__ */ new Error(`Tool approval request failed, make sure that there's a handler registered: ${String(error)}`), false);
+		return {
+			decision: "decline",
+			message: String(error)
+		};
+	}
+}
+/**
+* Handle file change approval request.
+*
+* Returns an immediate `decline` when the `patch` native tool is disabled by the
+* active harness, bypassing the normal approval flow.
+* Otherwise routes the JSON-RPC server request to the scoped bus via requestToolApproval.
+* @param request - Server request for file change approval
+* @param ctx - Approval context
+* @returns Approval response with decision and optional message
+*/
+async function handleFileChangeApprovalRequest(request, ctx) {
+	if (ctx.getDisabledNativeTools().has("patch")) return {
+		decision: "decline",
+		message: "patch tool is disabled by the active harness"
+	};
+	const params = request.params;
+	try {
+		return await ctx.requestToolApproval(CodexAppServerSubjects.file_change_approval_request, {
+			threadId: params.threadId,
+			turnId: params.turnId,
+			itemId: params.itemId,
+			reason: params.reason ?? null,
+			grantRoot: params.grantRoot ?? null,
+			timestamp: Date.now()
+		});
+	} catch (error) {
+		ctx.handleError(/* @__PURE__ */ new Error(`Tool approval request failed, make sure that there's a handler registered: ${String(error)}`), false);
+		return {
+			decision: "decline",
+			message: String(error)
+		};
+	}
+}
+/**
+* Emit a synthetic begin+end lifecycle pair for a denied or errored dynamic tool call.
+*
+* Denied tool calls never produce `item/started`/`item/completed` notifications from
+* codex, so the agent's `dynamic_tool_call_begin`/`end` handlers never fire. Emitting
+* the pair here ensures downstream consumers (e.g. AgentSubjects.tool.use) observe
+* every tool call regardless of its approval outcome.
+* @param params - Tool call parameters from the server request
+* @param output - Serialised error output to surface as the tool result
+* @param emit - Scoped bus emit function
+*/
+async function emitDeniedDynamicToolCallLifecycle(params, output, emit) {
+	const now = Date.now();
+	await emit(CodexAppServerSubjects.dynamic_tool_call_begin, {
+		threadId: params.threadId,
+		turnId: params.turnId,
+		itemId: params.itemId,
+		name: params.name,
+		args: params.arguments,
+		timestamp: now
+	});
+	await emit(CodexAppServerSubjects.dynamic_tool_call_end, {
+		threadId: params.threadId,
+		turnId: params.turnId,
+		itemId: params.itemId,
+		name: params.name,
+		output,
+		success: false,
+		timestamp: now
+	});
+}
+/**
+* Handle an `item/tool/call` server request (experimental API).
+*
+* Requests tool approval via the scoped bus before executing. If denied, returns error
+* content without executing. If approved, executes via bus and caches result under
+* `itemId` for lifecycle handler correlation.
+*
+* Denied calls emit a synthetic `dynamic_tool_call_begin`/`end` pair so that
+* downstream lifecycle consumers (e.g. `AgentSubjects.tool.use`) observe every
+* tool invocation regardless of approval outcome.
+* @param params - Parsed `item/tool/call` request parameters
+* @param ctx - Dynamic tool approval and execution context
+* @returns Content items to send back to codex
+*/
+async function handleDynamicToolCallApprovalRequest(params, ctx) {
+	let approval;
+	try {
+		approval = await ctx.requestToolApproval(CodexAppServerSubjects.dynamic_tool_call_approval_request, {
+			threadId: params.threadId,
+			turnId: params.turnId,
+			itemId: params.itemId,
+			name: params.name,
+			args: params.arguments,
+			timestamp: Date.now()
+		});
+	} catch (error) {
+		const errorText = JSON.stringify({ error: String(error) });
+		ctx.dynamicToolCallByItemId.set(params.itemId, {
+			name: params.name,
+			args: params.arguments,
+			output: errorText,
+			success: false
+		});
+		try {
+			await emitDeniedDynamicToolCallLifecycle(params, errorText, ctx.emit);
+		} catch {} finally {
+			ctx.dynamicToolCallByItemId.delete(params.itemId);
+		}
+		return { content: [{
+			type: "text",
+			text: errorText
+		}] };
+	}
+	if (approval?.decision !== "accept") {
+		const message = approval?.decision === "decline" ? approval.message ?? "Tool call denied by approval handler" : "Invalid approval response from approval handler";
+		const errorText = JSON.stringify({ error: message });
+		ctx.dynamicToolCallByItemId.set(params.itemId, {
+			name: params.name,
+			args: params.arguments,
+			output: errorText,
+			success: false
+		});
+		try {
+			await emitDeniedDynamicToolCallLifecycle(params, errorText, ctx.emit);
+		} catch {} finally {
+			ctx.dynamicToolCallByItemId.delete(params.itemId);
+		}
+		return { content: [{
+			type: "text",
+			text: errorText
+		}] };
+	}
+	const response = await handleDynamicToolCall(params, {
+		sessionId: ctx.sessionId,
+		agentId: ctx.agentId,
+		adapterId: ctx.adapterId,
+		adapterName: ctx.adapterName,
+		toolLedger: ctx.toolLedger,
+		currentTurnNumber: ctx.currentTurnNumber
+	});
+	const outputText = response.content[0]?.text ?? "";
+	const success = response.content.length > 0 && isDynamicToolCallSuccess(outputText);
+	ctx.dynamicToolCallByItemId.set(params.itemId, {
+		name: params.name,
+		args: params.arguments,
+		output: outputText,
+		success
+	});
+	return response;
+}
+
+//#endregion
+//#region src/connector/delta-handlers.ts
+/**
+* Delta event handlers for Codex App-Server notifications.
+*
+* These handle streaming content updates (agent messages, command output, reasoning, file changes).
+* @packageDocumentation
+*/
+/**
+* Create a type guard validator for a Zod schema.
+* Logs validation errors when parsing fails.
+* @param schema - The Zod schema to validate against
+* @param name - Human-readable name for error logging
+* @returns A type guard function that validates and logs errors
+*/
+function createValidator(schema, name) {
+	return (params) => {
+		const result = schema.safeParse(params);
+		if (!result.success) console.warn(`[delta-handlers] Invalid ${name} notification:`, result.error.format());
+		return result.success;
+	};
+}
+const isValidAgentMessageDeltaNotification = createValidator(z.union([z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	delta: z.string()
+}), z.object({ delta: z.string() })]), "agent message delta");
+const isValidCommandOutputDeltaNotification = createValidator(z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	itemId: z.string(),
+	delta: z.string()
+}), "command output delta");
+const isValidReasoningDeltaNotification = createValidator(z.union([z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	delta: z.string()
+}), z.object({ delta: z.string() })]), "reasoning delta");
+const isValidFileChangeDeltaNotification = createValidator(z.object({
+	threadId: z.string(),
+	turnId: z.string(),
+	itemId: z.string(),
+	delta: z.string()
+}), "file change delta");
+/**
+* Handle agent message delta notification.
+* @param emit - Bus emit function
+* @param params - Delta notification params
+* @param onAccumulate - Callback to accumulate content
+*/
+async function handleAgentMessageDelta(emit, params, onAccumulate) {
+	if (!isValidAgentMessageDeltaNotification(params)) {
+		console.warn("[delta-handlers] Skipping invalid agent message delta notification");
+		return;
+	}
+	const delta = params.delta;
+	onAccumulate(delta);
+	if ("threadId" in params) await emit(CodexAppServerSubjects.agent_message_delta, {
+		threadId: params.threadId,
+		turnId: params.turnId,
+		delta: params.delta,
+		timestamp: Date.now()
+	});
+	else console.warn("[CodexAppServerConnector] Agent message delta received without threadId, accumulating but not emitting");
+}
+/**
+* Handle command output delta notification.
+* @param emit - Bus emit function
+* @param params - Delta notification params
+*/
+async function handleCommandOutputDelta(emit, params) {
+	if (!isValidCommandOutputDeltaNotification(params)) {
+		console.warn("[delta-handlers] Skipping invalid command output delta notification");
+		return;
+	}
+	await emit(CodexAppServerSubjects.exec_command_output_delta, {
+		threadId: params.threadId,
+		turnId: params.turnId,
+		callId: params.itemId,
+		stream: "stdout",
+		chunk: params.delta,
+		timestamp: Date.now()
+	});
+}
+/**
+* Handle reasoning delta notification.
+* @param emit - Bus emit function
+* @param params - Delta notification params
+*/
+async function handleReasoningDelta(emit, params) {
+	if (!isValidReasoningDeltaNotification(params)) {
+		console.warn("[delta-handlers] Skipping invalid reasoning delta notification");
+		return;
+	}
+	if ("threadId" in params) await emit(CodexAppServerSubjects.reasoning_delta, {
+		threadId: params.threadId,
+		turnId: params.turnId,
+		delta: params.delta,
+		timestamp: Date.now()
+	});
+}
+/**
+* Handle file change delta notification.
+* @param emit - Bus emit function
+* @param params - Delta notification params
+*/
+async function handleFileChangeDelta(emit, params) {
+	if (!isValidFileChangeDeltaNotification(params)) {
+		console.warn("[delta-handlers] Skipping invalid file change delta notification");
+		return;
+	}
+	await emit(CodexAppServerSubjects.file_change_output_delta, {
+		threadId: params.threadId,
+		turnId: params.turnId,
+		itemId: params.itemId,
+		delta: params.delta,
+		timestamp: Date.now()
+	});
+}
+
+//#endregion
+//#region src/connector/lifecycle-handlers.ts
+/**
+* Extract thread ID from thread/started notification.
+* @param notification - Thread started notification
+* @returns Thread ID string
+*/
+function extractThreadId(notification) {
+	return notification.thread.id;
+}
+/**
+* Handle turn/started notification.
+* Acknowledges the message when the turn starts (server echoed it).
+* @param notification - Turn started notification
+* @param turn - Current turn instance
+* @param updateProcessingState - State update callback
+*/
+async function handleTurnStarted(notification, turn, updateProcessingState) {
+	if (!turn) {
+		console.warn("[CodexAppServerConnector] Received turn/started but no current turn");
+		return;
+	}
+	turn.markAcknowledged();
+	await turn.handleTurnStarted(notification.turn.id);
+	await updateProcessingState("processing_started");
+	await updateProcessingState("turn_started");
+}
+/**
+* Handle item/started notification.
+* @param notification - Item started notification
+* @param turn - Current turn instance
+* @param emit - Bus emit function
+* @param commandCache - Cache for command execution metadata
+* @param dynamicToolCallCache - Cache for dynamic tool call metadata and results
+* @param updateProcessingState - State update callback
+* @param onCommandInfoReady - Optional callback invoked after a commandExecution entry
+*   is written to `commandCache`. Used to unblock approval requests that arrived before
+*   this `item/started` notification.
+*/
+async function handleItemStarted(notification, turn, emit, commandCache, dynamicToolCallCache, updateProcessingState, onCommandInfoReady) {
+	if (!turn) return;
+	const item = notification.item;
+	const itemId = "id" in item ? item.id : "";
+	const itemType = item.type;
+	await turn.handleItemStarted(itemId, itemType);
+	await updateProcessingState("step_started");
+	if (item.type === "commandExecution") {
+		const info = {
+			command: item.command,
+			cwd: item.cwd
+		};
+		commandCache.set(item.id, info);
+		onCommandInfoReady?.(item.id, info);
+		await emit(CodexAppServerSubjects.exec_command_begin, {
+			threadId: notification.threadId,
+			turnId: notification.turnId,
+			callId: item.id,
+			command: [item.command],
+			cwd: item.cwd,
+			timestamp: Date.now()
+		});
+	}
+	if (itemType === "dynamicToolCall") {
+		const cached = dynamicToolCallCache.get(itemId);
+		if (cached) await emit(CodexAppServerSubjects.dynamic_tool_call_begin, {
+			threadId: notification.threadId,
+			turnId: notification.turnId,
+			itemId,
+			name: cached.name,
+			args: cached.args,
+			timestamp: Date.now()
+		});
+		else console.warn(`[lifecycle-handlers] dynamicToolCall item ${itemId} started with no cached tool call data`);
+	}
+}
+/**
+* Handle item/completed notification.
+* @param notification - Item completed notification
+* @param turn - Current turn instance
+* @param emit - Bus emit function
+* @param commandCache - Cache for command execution metadata
+* @param dynamicToolCallCache - Cache for dynamic tool call metadata and results
+* @param updateProcessingState - State update callback
+*/
+async function handleItemCompleted(notification, turn, emit, commandCache, dynamicToolCallCache, updateProcessingState) {
+	if (!turn) return;
+	const item = notification.item;
+	const itemId = "id" in item ? item.id : "";
+	const itemType = item.type;
+	await turn.handleItemCompleted(itemId);
+	await updateProcessingState("step_finished");
+	if (item.type === "commandExecution") {
+		await emit(CodexAppServerSubjects.exec_command_end, {
+			threadId: notification.threadId,
+			turnId: notification.turnId,
+			callId: item.id,
+			exitCode: item.exitCode ?? 0,
+			timestamp: Date.now()
+		});
+		commandCache.delete(item.id);
+		return;
+	}
+	if (itemType === "dynamicToolCall") {
+		const cached = dynamicToolCallCache.get(itemId);
+		if (cached) {
+			await emit(CodexAppServerSubjects.dynamic_tool_call_end, {
+				threadId: notification.threadId,
+				turnId: notification.turnId,
+				itemId,
+				name: cached.name,
+				output: cached.output,
+				success: cached.success,
+				timestamp: Date.now()
+			});
+			dynamicToolCallCache.delete(itemId);
+		} else console.warn(`[lifecycle-handlers] dynamicToolCall item ${itemId} completed with no cached tool call data`);
+		return;
+	}
+	await emit(CodexAppServerSubjects.item_completed, {
+		threadId: notification.threadId,
+		turnId: notification.turnId,
+		itemId,
+		itemType,
+		timestamp: Date.now()
+	});
+}
+/**
+* Handle token usage updated notification.
+* @param notification - Token usage notification
+* @param thread - Current thread instance
+*/
+async function handleTokenUsageUpdated(notification, thread) {
+	if (!thread) return;
+	await thread.handleTokenUsageUpdated(notification.tokenUsage.last.inputTokens, notification.tokenUsage.last.cachedInputTokens, notification.tokenUsage.last.outputTokens, notification.tokenUsage.last.reasoningOutputTokens, notification.tokenUsage.last.totalTokens, notification.tokenUsage.modelContextWindow ?? void 0);
+}
+
+//#endregion
+//#region src/connector/client-handlers.ts
+/**
+* Register JSON-RPC notification handlers for the connector client instance.
+* @param options - Callbacks and state accessors used to bridge notifications into connector state
+*/
+function registerNotificationHandlers(options) {
+	const { client, enqueueNotification, onThreadStarted, consumeTurnNumber, getCurrentTurn, emit, commandExecutionByItemId, dynamicToolCallByItemId, updateProcessingState, appendAgentMessageDelta, onTurnCompleted, getThread, handleAsyncError, onCommandInfoReady } = options;
+	client.onNotification("thread/started", (_method, params) => {
+		enqueueNotification(() => onThreadStarted(params));
+	});
+	client.onNotification("turn/started", (_method, params) => {
+		consumeTurnNumber();
+		enqueueNotification(() => handleTurnStarted(params, getCurrentTurn(), updateProcessingState));
+	});
+	client.onNotification("item/started", (_method, params) => {
+		enqueueNotification(() => handleItemStarted(params, getCurrentTurn(), emit, commandExecutionByItemId, dynamicToolCallByItemId, updateProcessingState, onCommandInfoReady));
+	});
+	client.onNotification("item/completed", (_method, params) => {
+		enqueueNotification(() => handleItemCompleted(params, getCurrentTurn(), emit, commandExecutionByItemId, dynamicToolCallByItemId, updateProcessingState));
+	});
+	client.onNotification("item/agentMessage/delta", (_method, params) => {
+		handleAgentMessageDelta(emit, params, appendAgentMessageDelta).catch(handleAsyncError);
+	});
+	client.onNotification("item/commandExecution/outputDelta", (_method, params) => {
+		handleCommandOutputDelta(emit, params).catch(handleAsyncError);
+	});
+	client.onNotification("item/reasoning/textDelta", (_method, params) => {
+		handleReasoningDelta(emit, params).catch(handleAsyncError);
+	});
+	client.onNotification("item/fileChange/outputDelta", (_method, params) => {
+		handleFileChangeDelta(emit, params).catch(handleAsyncError);
+	});
+	client.onNotification("turn/completed", (_method, params) => {
+		enqueueNotification(() => onTurnCompleted(params));
+	});
+	client.onNotification("thread/tokenUsage/updated", (_method, params) => {
+		Promise.resolve(handleTokenUsageUpdated(params, getThread())).catch(handleAsyncError);
+	});
+}
+/**
+* Register the JSON-RPC server-request handler for approval and dynamic tool call flows.
+* @param options - Callbacks and state accessors needed to answer server requests
+*/
+function registerServerRequestHandler(options) {
+	const ctx = {
+		agentId: options.agentId,
+		cwd: options.cwd,
+		commandExecutionByItemId: options.commandExecutionByItemId,
+		requestToolApproval: options.requestToolApproval,
+		handleError: options.handleError,
+		getDisabledNativeTools: options.getDisabledNativeTools,
+		waitForCommandInfo: options.waitForCommandInfo
+	};
+	options.client.onServerRequest(async (request) => {
+		const asMethodRequest = request;
+		if (isDynamicToolCallRequest(asMethodRequest)) return options.handleDynamicToolCallRequest(asMethodRequest.params);
+		if (request.method === "item/commandExecution/requestApproval") return handleCommandApprovalRequest(request, ctx);
+		if (request.method === "item/fileChange/requestApproval") return handleFileChangeApprovalRequest(request, ctx);
+		throw new Error(`Unknown server request: ${request.method}`);
+	});
+}
+
+//#endregion
+//#region ../../../packages/subprocess/src/json-rpc-client.ts
+/** Default request timeout for JSON-RPC calls. */
+const DEFAULT_JSON_RPC_REQUEST_TIMEOUT_MS = 6e4;
+/**
+* Create a JSON-RPC 2.0 client on top of a JSONL transport.
+*
+* Message dispatch rules (JSON-RPC 2.0):
+* - `id` + `result`  → correlated response (resolves pending promise)
+* - `id` + `error`   → correlated error response (rejects pending promise)
+* - `id` + `method`  → server-initiated request (call handlers, send response)
+* - `method`, no `id` → notification (call method-specific handler)
+* @param transport - JSONL transport to send/receive messages on.
+* @returns JSON-RPC 2.0 client interface.
+*/
+function createJsonRpcClient$1(transport) {
+	let nextId = 1;
+	let closed = false;
+	const pendingRequests = /* @__PURE__ */ new Map();
+	const notificationHandlers = /* @__PURE__ */ new Map();
+	const serverRequestHandlers = /* @__PURE__ */ new Set();
+	/**
+	* Generate a unique, monotonically increasing request ID.
+	* @returns Next available request ID.
+	*/
+	function generateRequestId() {
+		return nextId++;
+	}
+	/**
+	* Reject all pending requests with the given error and clear the map.
+	* @param error - Error to reject all pending requests with.
+	*/
+	function rejectAllPending(error) {
+		for (const [, pending] of pendingRequests) {
+			if (pending.timeoutId !== null) clearTimeout(pending.timeoutId);
+			pending.reject(error);
+		}
+		pendingRequests.clear();
+	}
+	/**
+	* Resolve or reject a pending request exactly once and clear its timer.
+	* @param id - Request ID to settle.
+	* @param settle - Callback receiving the pending request callbacks.
+	*/
+	function settlePending(id, settle) {
+		const pending = pendingRequests.get(id);
+		if (!pending) return;
+		if (pending.timeoutId !== null) clearTimeout(pending.timeoutId);
+		pendingRequests.delete(id);
+		settle(pending);
+	}
+	/**
+	* Dispatch an incoming message according to JSON-RPC 2.0 semantics.
+	* @param message - Raw parsed message from the transport.
+	*/
+	function handleMessage(message) {
+		if (typeof message !== "object" || message === null) return;
+		const msg = message;
+		const id = "id" in msg ? msg["id"] : void 0;
+		if (id !== void 0 && "result" in msg && !("method" in msg)) {
+			settlePending(id, (pending) => {
+				pending.resolve(msg["result"]);
+			});
+			return;
+		}
+		if (id !== void 0 && "error" in msg && !("method" in msg)) {
+			settlePending(id, (pending) => {
+				const rpcError = msg["error"];
+				pending.reject(/* @__PURE__ */ new Error(`JSON-RPC error ${rpcError.code}: ${rpcError.message}`));
+			});
+			return;
+		}
+		if (id !== void 0 && "method" in msg) {
+			handleServerRequest(message, id, msg["method"]);
+			return;
+		}
+		if ("method" in msg && !("id" in msg)) {
+			const method = msg["method"];
+			const handlers = notificationHandlers.get(method);
+			if (handlers) for (const handler of handlers) try {
+				handler(method, msg["params"]);
+			} catch {}
+			return;
+		}
+	}
+	/**
+	* Dispatch a server-initiated request to registered handlers.
+	* @param message - Raw JSON-RPC request message.
+	* @param requestId - JSON-RPC request ID to echo in the response.
+	* @param method - JSON-RPC method name.
+	*/
+	async function handleServerRequest(message, requestId, method) {
+		const handlers = [...serverRequestHandlers];
+		if (handlers.length === 0) {
+			transport.send({
+				jsonrpc: "2.0",
+				id: requestId,
+				error: {
+					code: -32601,
+					message: `No handler registered for server request: ${method}`
+				}
+			});
+			return;
+		}
+		const results = await Promise.allSettled(handlers.map((handler) => Promise.resolve().then(() => handler(message))));
+		if (closed) return;
+		const success = results.find((result) => result.status === "fulfilled");
+		if (success) {
+			transport.send({
+				jsonrpc: "2.0",
+				id: requestId,
+				result: success.value
+			});
+			return;
+		}
+		const reason = results[0]?.reason;
+		const messageText = reason instanceof Error ? reason.message : String(reason ?? "handler failed");
+		transport.send({
+			jsonrpc: "2.0",
+			id: requestId,
+			error: {
+				code: -32603,
+				message: messageText
+			}
+		});
+	}
+	const unsubMessage = transport.onMessage(handleMessage);
+	const unsubError = transport.onError((error) => {
+		rejectAllPending(error);
+	});
+	return {
+		request(method, params, timeoutMs = DEFAULT_JSON_RPC_REQUEST_TIMEOUT_MS) {
+			if (closed) return Promise.reject(/* @__PURE__ */ new Error("JSON-RPC client is closed"));
+			return new Promise((resolve, reject) => {
+				const id = generateRequestId();
+				const requestMessage = {
+					jsonrpc: "2.0",
+					id,
+					method,
+					params
+				};
+				const timeoutId = timeoutMs === 0 ? null : setTimeout(() => {
+					settlePending(id, (pending) => {
+						pending.reject(/* @__PURE__ */ new Error(`JSON-RPC request timed out after ${timeoutMs}ms: ${method}`));
+					});
+				}, timeoutMs);
+				pendingRequests.set(id, {
+					resolve,
+					reject,
+					timeoutId
+				});
+				try {
+					transport.send(requestMessage);
+				} catch (error) {
+					settlePending(id, (pending) => {
+						pending.reject(error instanceof Error ? error : new Error(String(error)));
+					});
+				}
+			});
+		},
+		notification(method, params) {
+			if (closed) return;
+			const msg = {
+				jsonrpc: "2.0",
+				method,
+				params
+			};
+			transport.send(msg);
+		},
+		onNotification(method, handler) {
+			let handlers = notificationHandlers.get(method);
+			if (!handlers) {
+				handlers = /* @__PURE__ */ new Set();
+				notificationHandlers.set(method, handlers);
+			}
+			handlers.add(handler);
+			return () => {
+				handlers.delete(handler);
+				if (handlers.size === 0) notificationHandlers.delete(method);
+			};
+		},
+		onServerRequest(handler) {
+			serverRequestHandlers.add(handler);
+			return () => {
+				serverRequestHandlers.delete(handler);
+			};
+		},
+		close() {
+			if (closed) return;
+			closed = true;
+			unsubMessage();
+			unsubError();
+			rejectAllPending(/* @__PURE__ */ new Error("JSON-RPC client closed"));
+			notificationHandlers.clear();
+			serverRequestHandlers.clear();
+			transport.close();
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/jsonRpcClient.ts
+/**
+* Creates a JSON-RPC 2.0 client wrapping a stdio transport
+* @param transport - Stdio transport for sending/receiving messages
+* @returns JSON-RPC client interface
+* @example
+* ```ts
+* const transport = createStdioTransport(cwd, env);
+* const client = createJsonRpcClient(transport);
+*
+* // Send request
+* const result = await client.request('thread/start', { ... });
+*
+* // Send notification
+* client.notification('initialized', {});
+*
+* // Handle notifications
+* client.onNotification('turn/started', (method, params) => {
+*   console.log('Turn started:', params);
+* });
+*
+* // Handle server requests (approvals)
+* client.onServerRequest(async (request) => {
+*   return { decision: 'accept' };
+* });
+* ```
+*/
+function createJsonRpcClient(transport) {
+	const generic = createJsonRpcClient$1({
+		send: (msg) => transport.send(msg),
+		close: () => transport.close(),
+		onMessage: (listener) => {
+			transport.onMessage((msg) => listener(msg));
+			return () => {};
+		},
+		onError: (listener) => {
+			transport.onError((err) => listener(err));
+			return () => {};
+		},
+		get process() {}
+	});
+	let serverRequestUnsubscribe;
+	return {
+		/**
+		* Send a JSON-RPC request and wait for response
+		* @param method - Method name to call
+		* @param params - Method parameters
+		* @returns Promise resolving to response result
+		*/
+		request(method, params) {
+			return generic.request(method, params);
+		},
+		/**
+		* Send a JSON-RPC notification (no response expected)
+		* @param method - Notification method name
+		* @param params - Notification parameters
+		*/
+		notification(method, params) {
+			generic.notification(method, params);
+		},
+		/**
+		* Register a handler for specific notification type
+		* @param method - Notification method name to handle
+		* @param handler - Function to handle notifications
+		*/
+		onNotification(method, handler) {
+			generic.onNotification(method, handler);
+		},
+		/**
+		* Register a handler for server requests (approvals)
+		* @param handler - Function to handle server requests
+		*/
+		onServerRequest(handler) {
+			serverRequestUnsubscribe?.();
+			serverRequestUnsubscribe = generic.onServerRequest((req) => handler(req));
+		},
+		/**
+		* Close the client and cleanup resources
+		*/
+		close() {
+			serverRequestUnsubscribe?.();
+			serverRequestUnsubscribe = void 0;
+			generic.close();
+		}
+	};
+}
+
+//#endregion
+//#region src/utils/createStdioTransport.ts
+/**
+* Resolve the command used to start the Codex app server.
+* @param binaryPath - Optional resolved managed binary path.
+* @returns Absolute managed binary path, or the PATH-resolved `codex` command.
+*/
+function resolveSpawnCommand(binaryPath) {
+	if (binaryPath === void 0) return "codex";
+	if (binaryPath.trim() === "" || !path.isAbsolute(binaryPath)) throw new Error("binaryPath must be a non-empty absolute path when provided");
+	return binaryPath;
+}
+/**
+* Creates a stdio transport for communicating with codex app-server subprocess
+* @param cwd - Working directory for the subprocess
+* @param env - Environment variables to pass to the subprocess (undefined values are filtered out)
+* @param binaryPath - Absolute path to the codex binary; when omitted, `'codex'` is resolved from PATH
+* @returns Transport interface for sending/receiving messages
+* @throws Error if subprocess fails to spawn
+* @example
+* ```ts
+* const transport = createStdioTransport('/path/to/project', { PATH: process.env.PATH });
+* transport.onMessage((message) => console.log('Received:', message));
+* transport.send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+* ```
+*/
+function createStdioTransport(cwd, env, binaryPath) {
+	const subprocess = spawn(resolveSpawnCommand(binaryPath), ["app-server"], {
+		cwd,
+		env: {
+			...Object.fromEntries(Object.entries(env).filter(([, value]) => value !== void 0)),
+			RUST_LOG: "debug"
+		},
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+	let messageCallback = null;
+	let errorCallback = null;
+	let buffer = "";
+	/**
+	* Parse JSONL from stdout and dispatch messages
+	*/
+	subprocess.stdout.on("data", (chunk) => {
+		buffer += chunk.toString("utf-8");
+		const lines = buffer.split("\n");
+		buffer = lines.pop() || "";
+		for (const line of lines) if (line.trim()) try {
+			const message = JSON.parse(line);
+			messageCallback?.(message);
+		} catch (err) {
+			const error = err instanceof Error ? err : /* @__PURE__ */ new Error(`Failed to parse JSONL: ${line}`);
+			errorCallback?.(error);
+		}
+	});
+	subprocess.stderr.on("data", (chunk) => {
+		console.warn("[codex app-server]", chunk.toString("utf-8"));
+	});
+	/**
+	* Handle subprocess errors (e.g., codex not found)
+	*/
+	subprocess.on("error", (error) => {
+		errorCallback?.(error);
+	});
+	/**
+	* Handle subprocess exit
+	*/
+	subprocess.on("exit", (code) => {
+		if (code !== 0) {
+			const error = /* @__PURE__ */ new Error(`codex app-server exited with code ${code ?? "unknown"}`);
+			errorCallback?.(error);
+		}
+	});
+	return {
+		/**
+		* Send a JSON-RPC message to the subprocess via stdin
+		* @param message - JSON-RPC message to send (request, response, or notification)
+		*/
+		send(message) {
+			subprocess.stdin.write(JSON.stringify(message) + "\n");
+		},
+		/**
+		* Close the subprocess and cleanup resources
+		*/
+		close() {
+			subprocess.kill();
+		},
+		/**
+		* Register a callback for incoming messages
+		* @param callback - Function to handle incoming messages
+		*/
+		onMessage(callback) {
+			messageCallback = callback;
+		},
+		/**
+		* Register a callback for errors
+		* @param callback - Function to handle errors
+		*/
+		onError(callback) {
+			errorCallback = callback;
+		}
+	};
+}
+
+//#endregion
+//#region src/connector/types.ts
+/**
+* Client info for JSON-RPC initialize handshake.
+*/
+const CLIENT_INFO = {
+	name: "makaio-codex-app-server",
+	title: "Makaio Codex App-Server",
+	version: "0.1.0"
+};
+
+//#endregion
+//#region src/connector/connection-manager.ts
+/**
+* Connection lifecycle management for the Codex App-Server connector.
+*
+* Handles JSON-RPC client creation, subprocess spawning, credential resolution,
+* the ACP `initialize` handshake, and error-path teardown. The connector holds all
+* mutable state; this module mutates it only through the typed accessors in
+* {@link ConnectionManagerContext}.
+* @packageDocumentation
+*/
+/**
+* Create and attach the JSON-RPC client to the connector.
+*
+* If the context already has a client (from a test injection or a prior call),
+* only registers handlers and returns immediately. Otherwise, resolves credentials
+* and the managed binary path, spawns the subprocess via stdio transport, and
+* registers the error callback.
+* @param ctx - Connection manager context
+*/
+async function createClient(ctx) {
+	if (ctx.getJsonRpcClient()) {
+		ctx.registerClientHandlers();
+		return;
+	}
+	const injected = ctx.getInjectedJsonRpcClient();
+	if (injected) {
+		ctx.setJsonRpcClient(injected);
+		ctx.registerClientHandlers();
+		return;
+	}
+	const { resolvedBinary, spawnEnv } = await resolveSessionEnvironment({
+		bus: ctx.bus,
+		providerContext: ctx.providerContext,
+		clientId: ctx.clientId ?? "codex",
+		baseEnv: ctx.env
+	});
+	const transport = ctx.getInjectedTransport() ?? createStdioTransport(ctx.cwd, spawnEnv, resolvedBinary?.binaryPath ?? void 0);
+	if (!ctx.getInjectedTransport()) ctx.setOwnedTransport(transport);
+	ctx.setJsonRpcClient(createJsonRpcClient(transport));
+	transport.onError((error) => ctx.handleError(error, true));
+	ctx.registerClientHandlers();
+}
+/**
+* Tear down the active JSON-RPC client and owned transport after a connection failure.
+*
+* Resets connection and handler-registration flags so the next `initializeConnection`
+* call starts fresh. If an injected test client is present it is restored (not closed)
+* so the test can continue using the same mock instance.
+* @param ctx - Connection manager context
+*/
+function resetClient(ctx) {
+	ctx.setIsConnected(false);
+	ctx.setClientHandlersRegistered(false);
+	ctx.setDisabledNativeTools(/* @__PURE__ */ new Set());
+	const transport = ctx.getOwnedTransport();
+	ctx.setOwnedTransport(void 0);
+	const injected = ctx.getInjectedJsonRpcClient();
+	if (!injected) {
+		ctx.getJsonRpcClient()?.close();
+		if (!ctx.getJsonRpcClient() && transport) transport.close();
+		ctx.setJsonRpcClient(void 0);
+		return;
+	}
+	ctx.setJsonRpcClient(injected);
+}
+/**
+* Perform the full ACP `initialize` handshake in a single flight.
+*
+* Spawns the subprocess (or reuses an injected client), resolves disabled native
+* tools via the global harness bus, sends `initialize`, and fires `initialized`.
+* On any error the client is torn down via {@link resetClient} before re-throwing
+* so the next call starts from a clean state.
+* @param ctx - Connection manager context
+*/
+async function performConnectionInit(ctx) {
+	try {
+		await createClient(ctx);
+		ctx.setDisabledNativeTools(new Set(await resolveDisabledNativeTools(MakaioBus, ctx.adapterName, ctx.harnessId, ctx.clientId)));
+		const initParams = {
+			clientInfo: CLIENT_INFO,
+			capabilities: { experimentalApi: true }
+		};
+		const client = ctx.getJsonRpcClient();
+		if (!client) throw new Error("JSON-RPC client not initialized");
+		await client.request("initialize", initParams);
+		client.notification("initialized", {});
+		ctx.setIsConnected(true);
+	} catch (error) {
+		resetClient(ctx);
+		throw error;
+	}
+}
+/**
+* Ensure the connector is connected, using single-flight deduplication.
+*
+* Concurrent callers share the same in-flight promise so the subprocess is spawned
+* exactly once. Resolves immediately when already connected.
+* @param ctx - Connection manager context
+* @param inflight - Mutable holder for the in-flight promise; updated by this function
+* @returns Promise that resolves when the connection is established
+*/
+function initializeConnection(ctx, inflight) {
+	if (ctx.getIsConnected()) return Promise.resolve();
+	inflight.promise ??= performConnectionInit(ctx).finally(() => {
+		inflight.promise = void 0;
+	});
+	return inflight.promise;
+}
+
+//#endregion
+//#region src/thread.ts
+/**
+* Thread lifecycle management for Codex App-Server.
+*
+* Tracks thread state and emits namespace bus events:
+* - thread_started when thread/started notification received
+* - thread_completed when thread is archived or completed
+* - token_usage when thread/tokenUsage/updated received
+*
+* Thread is created by connector when thread/start response is received,
+* and updated throughout the conversation via notifications.
+*/
+var CodexAppServerThread = class {
+	bus;
+	adapterId;
+	agentId;
+	_threadId;
+	_state = "active";
+	_config = {};
+	_tokenUsage;
+	constructor(config) {
+		this.bus = config.bus;
+		this.adapterId = config.adapterId;
+		this.agentId = config.agentId;
+	}
+	/**
+	* Get the thread ID.
+	* @returns Thread ID or undefined if not yet started
+	*/
+	get threadId() {
+		return this._threadId;
+	}
+	/**
+	* Get the current thread state.
+	* @returns Current thread state
+	*/
+	get state() {
+		return this._state;
+	}
+	/**
+	* Get the thread configuration.
+	* @returns Thread configuration overrides
+	*/
+	get config() {
+		return { ...this._config };
+	}
+	/**
+	* Get the current token usage.
+	* @returns Token usage or undefined if not yet received
+	*/
+	get tokenUsage() {
+		return this._tokenUsage;
+	}
+	/**
+	* Check if thread is active.
+	* @returns True if thread is active
+	*/
+	isActive() {
+		return this._state === "active";
+	}
+	/**
+	* Check if thread is completed.
+	* @returns True if thread is completed
+	*/
+	isCompleted() {
+		return this._state === "completed";
+	}
+	/**
+	* Handle thread/started notification.
+	* Sets threadId and transitions to active state.
+	* @param threadId - Thread ID from thread/started notification
+	*/
+	async handleThreadStarted(threadId) {
+		this._threadId = threadId;
+		this._state = "active";
+		await this.bus.emit(CodexAppServerSubjects.thread_started, {
+			agentId: this.agentId,
+			threadId: this._threadId,
+			timestamp: Date.now()
+		});
+	}
+	/**
+	* Handle thread completion or archival.
+	* Transitions state and emits completion event.
+	* @param newState - New thread state (completed or archived)
+	*/
+	async handleThreadCompleted(newState = "completed") {
+		if (!this._threadId) throw new Error("Cannot complete thread: threadId not set");
+		this._state = newState;
+		await this.bus.emit(CodexAppServerSubjects.thread_completed, {
+			agentId: this.agentId,
+			threadId: this._threadId,
+			timestamp: Date.now()
+		});
+	}
+	/**
+	* Handle thread/tokenUsage/updated notification.
+	* Updates token usage tracking.
+	* @param promptTokens - Prompt/input tokens used
+	* @param inputCachedTokens - Cached input tokens reused for this update
+	* @param completionTokens - Completion/output tokens used
+	* @param reasoningTokens - Reasoning output tokens used (subset of completionTokens)
+	* @param totalTokens - Full protocol-reported total for this update
+	* @param modelContextWindow - Optional model context window size
+	*/
+	async handleTokenUsageUpdated(promptTokens, inputCachedTokens, completionTokens, reasoningTokens, totalTokens, modelContextWindow) {
+		this._tokenUsage = {
+			promptTokens,
+			inputCachedTokens,
+			completionTokens,
+			reasoningTokens,
+			totalTokens,
+			modelContextWindow
+		};
+		await this.bus.emit(CodexAppServerSubjects.token_usage, {
+			agentId: this.agentId,
+			threadId: this._threadId ?? "",
+			promptTokens,
+			inputCachedTokens,
+			completionTokens,
+			reasoningTokens,
+			totalTokens,
+			modelContextWindow,
+			timestamp: Date.now()
+		});
+	}
+	/**
+	* Update thread configuration.
+	* Used for per-turn overrides.
+	* @param config - Configuration updates
+	*/
+	updateConfig(config) {
+		this._config = {
+			...this._config,
+			...config
+		};
+	}
+};
+
+//#endregion
+//#region src/turn.ts
+/**
+* Codex App-Server Turn State Machine
+*
+* Manages turn lifecycle for the codex app-server protocol.
+* A turn is a single user input → agent response cycle within a thread.
+*
+* State machine follows the app-server protocol:
+* - idle → active (turn/start request sent)
+* - active → processing_started (turn/started notification received)
+* - processing_started → turn_started (first item/started notification)
+* - turn_started → step_started (command/file item starts)
+* - step_started → step_finished (item completes)
+* - step_finished → turn_finished (turn/completed received)
+* - turn_finished → idle (cleanup, ready for next turn)
+*
+* Immediate mode: active → interrupted → idle (cancelled, new turn with merged content)
+*/
+/**
+* Turn state machine for Codex App-Server.
+*
+* Tracks state transitions based on app-server notifications:
+* - turn/started → processing_started state
+* - item/started → step_started state
+* - item/completed → step_finished state
+* - turn/completed → turn_finished state
+*
+* Similar to codex-mcp but adapted for app-server protocol:
+* - Uses turnId instead of taskId
+* - Item-based events instead of MCP event types
+* - Supports interrupt via turn/interrupt method
+*/
+var CodexAppServerTurn = class extends BaseConnectorTurn {
+	connectorBus;
+	agentId;
+	threadId;
+	activeMessageHandle;
+	turnId;
+	currentItemId;
+	currentItemType;
+	interrupted = false;
+	constructor(bus, adapterId, adapterName, agentId, threadId, messageHandle) {
+		super(bus, adapterId, adapterName, "idle");
+		this.connectorBus = bus;
+		this.agentId = agentId;
+		this.threadId = threadId;
+		this.activeMessageHandle = messageHandle;
+	}
+	/**
+	* Get the turn ID.
+	* @returns Turn ID or undefined if not yet received from turn/started
+	*/
+	getTurnId() {
+		return this.turnId;
+	}
+	/**
+	* Set the turn ID from turn/started notification.
+	* @param turnId - Turn ID from the app-server
+	*/
+	setTurnId(turnId) {
+		this.turnId = turnId;
+	}
+	/**
+	* Get the current item ID being processed.
+	* @returns Current item ID or undefined
+	*/
+	getCurrentItemId() {
+		return this.currentItemId;
+	}
+	/**
+	* Emit state change using typed namespace subjects.
+	* @param oldState - The previous turn state
+	* @param newState - The new turn state
+	*/
+	async emitStateChange(oldState, newState) {
+		const payload = {
+			adapterId: this.adapterId,
+			agentId: this.agentId,
+			oldState,
+			newState,
+			timestamp: Date.now()
+		};
+		await this.connectorBus.emit(CodexAppServerSubjects.turn_state_changed, payload);
+		switch (newState) {
+			case "turn_started":
+				await this.connectorBus.emit(CodexAppServerSubjects.turn_started, {
+					agentId: this.agentId,
+					threadId: this.threadId,
+					turnId: this.turnId ?? "",
+					timestamp: Date.now()
+				});
+				break;
+			case "step_started":
+				await this.connectorBus.emit(CodexAppServerSubjects.turn_step_started, {
+					agentId: this.agentId,
+					threadId: this.threadId,
+					turnId: this.turnId ?? "",
+					itemId: this.currentItemId ?? "",
+					timestamp: Date.now()
+				});
+				break;
+			case "step_finished":
+				await this.connectorBus.emit(CodexAppServerSubjects.turn_step_finished, {
+					agentId: this.agentId,
+					threadId: this.threadId,
+					turnId: this.turnId ?? "",
+					itemId: this.currentItemId ?? "",
+					timestamp: Date.now()
+				});
+				break;
+			case "turn_finished":
+				await this.connectorBus.emit(CodexAppServerSubjects.turn_completed, {
+					agentId: this.agentId,
+					threadId: this.threadId,
+					turnId: this.turnId ?? "",
+					timestamp: Date.now()
+				});
+				break;
+		}
+	}
+	/**
+	* Start the turn - transition to active state.
+	* Called when turn/start request is sent.
+	*/
+	async start() {
+		await this.transitionTo("active");
+	}
+	/**
+	* Handle turn/started notification.
+	* Transitions from active to processing_started.
+	* @param turnId - Turn ID from the notification
+	*/
+	async handleTurnStarted(turnId) {
+		this.turnId = turnId;
+		await this.transitionTo("processing_started");
+	}
+	/**
+	* Handle item/started notification.
+	* Transitions from processing_started to turn_started (first item)
+	* or from step_finished to step_started (subsequent items).
+	* @param itemId - Item ID from the notification
+	* @param itemType - Type of item (agentMessage, commandExecution, etc.)
+	*/
+	async handleItemStarted(itemId, itemType) {
+		this.currentItemId = itemId;
+		this.currentItemType = itemType;
+		if (this.state === "processing_started") {
+			await this.transitionTo("turn_started");
+			await this.transitionTo("step_started");
+		} else if (this.state === "step_finished") await this.transitionTo("step_started");
+	}
+	/**
+	* Handle item/completed notification.
+	* Transitions from step_started to step_finished.
+	* @param itemId - Item ID from the notification
+	*/
+	async handleItemCompleted(itemId) {
+		if (this.currentItemId !== itemId) return;
+		if (this.state === "step_started") await this.transitionTo("step_finished");
+	}
+	/**
+	* Handle turn/completed notification.
+	* Transitions from step_finished to turn_finished.
+	*/
+	async handleTurnCompleted() {
+		if (this.state === "step_finished" || this.state === "turn_started") await this.transitionTo("turn_finished");
+	}
+	/**
+	* Mark turn as finished.
+	* Called by connector when turn completes.
+	*/
+	async markTurnFinished() {
+		await this.transitionTo("turn_finished");
+	}
+	/**
+	* Interrupt (pause) the turn.
+	* Used for immediate mode - sends turn/interrupt and restarts with merged content.
+	* @returns Pause result indicating whether turn had already ended
+	*/
+	async pause() {
+		if (this.state === "turn_finished") return {
+			stateBeforePause: this.state,
+			turnEnded: true
+		};
+		const stateBeforePause = this.state;
+		this.interrupted = true;
+		return {
+			stateBeforePause,
+			turnEnded: false
+		};
+	}
+	/**
+	* Resume is a no-op for app-server - caller creates new turn instead.
+	* App-server doesn't support true resume - use interrupt + restart with merged content.
+	* @param _message - Optional message (unused - app-server doesn't support resume)
+	* @throws Error always - app-server requires creating a new turn with merged content
+	*/
+	async resume(_message) {
+		throw new Error("Codex app-server does not support resume - create new turn with merged content");
+	}
+	/**
+	* Check if turn was interrupted.
+	* @returns True if turn was interrupted
+	*/
+	isPaused() {
+		return this.interrupted;
+	}
+	/**
+	* Check if turn is completed.
+	* @returns True if turn has finished
+	*/
+	isCompleted() {
+		return this.state === "turn_finished";
+	}
+	/**
+	* Check if turn can accept immediate message.
+	* True if turn is active (not finished, not interrupted).
+	* @returns True if turn can accept an immediate message
+	*/
+	canAcceptImmediate() {
+		return this.state !== "turn_finished" && !this.interrupted;
+	}
+};
+
+//#endregion
+//#region src/utils/attachmentHelpers.ts
+/**
+* Helpers for converting message blocks to Codex `UserInput` items.
+*
+* Kept separate from the connector to respect its max-lines budget and to
+* allow independent testing of the conversion logic.
+*/
+/**
+* Decode a base64-encoded string to UTF-8 text.
+*
+* Uses Web-standard `TextDecoder`/`atob` so this works in both browser and
+* Node.js (16+) environments. Returns an empty string on malformed input
+* rather than propagating the `DOMException` thrown by `atob`.
+* @param data - Base64-encoded string.
+* @returns Decoded UTF-8 string, or `''` if `data` is not valid base64.
+*/
+function decodeBase64Text(data) {
+	try {
+		return new TextDecoder().decode(Uint8Array.from(atob(data), (c) => c.charCodeAt(0)));
+	} catch {
+		return "";
+	}
+}
+/**
+* Return true when a MIME type represents plain-text or text-like content
+* that Codex can consume as a text input rather than a binary blob.
+* @param mimeType - MIME type string to test, or `undefined`.
+* @returns `true` when the MIME type is considered text-based.
+*/
+function isTextMimeType(mimeType) {
+	if (!mimeType) return false;
+	if (mimeType.startsWith("text/")) return true;
+	return [
+		"application/json",
+		"application/xml",
+		"application/sql",
+		"application/graphql",
+		"application/javascript",
+		"application/typescript",
+		"application/x-yaml",
+		"application/toml"
+	].includes(mimeType);
+}
+/**
+* Convert a single {@link MessageBlock} to a Codex {@link UserInput}, or
+* `null` when the block type has no Codex representation (e.g. tool_call).
+*
+* Dispatch rules:
+* - `text` → `{ type: 'text' }`
+* - `image` with URL source → `{ type: 'image' }`
+* - `image` with base64 source → `null` (unsupported; Codex only accepts local paths via attachment blocks)
+* - `attachment` with image MIME → `{ type: 'localImage' }` (uses `filePath`)
+* - `attachment` with text-like MIME → decoded `{ type: 'text' }`
+* - `attachment` otherwise → `{ type: 'text' }` placeholder via `serializeBlockToText`
+* - all other block types → `null` (skipped)
+* @param block - The normalized message block to convert.
+* @returns A Codex `UserInput` or `null` if the block should be skipped.
+*/
+function convertBlockToUserInput(block) {
+	if (block.type === "text") return {
+		type: "text",
+		text: block.content
+	};
+	if (block.type === "image" && block.source.type === "url") return {
+		type: "image",
+		url: block.source.url
+	};
+	if (block.type === "image" && block.source.type === "base64") return null;
+	if (block.type === "attachment") {
+		const mimeType = block.source.type === "base64" ? block.source.mimeType : void 0;
+		if (mimeType?.startsWith("image/")) return {
+			type: "localImage",
+			path: block.filePath
+		};
+		if (isTextMimeType(mimeType) && block.source.type === "base64") return {
+			type: "text",
+			text: decodeBase64Text(block.source.data)
+		};
+		return {
+			type: "text",
+			text: serializeBlockToText(block)
+		};
+	}
+	return null;
+}
+
+//#endregion
+//#region src/utils/formatMessageHistory.ts
+/**
+* Format message history as a prompt prefix for codex app-server.
+*
+* Since the codex app-server protocol's turn/start only accepts user input,
+* we serialize the message history into a human-readable format that
+* the AI can understand as conversation context.
+*/
+/**
+* Format curated message history as a text prefix.
+*
+* Serializes the history into a format the AI can understand as prior context.
+* Uses role labels to distinguish different message types.
+* @param history - Curated messages from sessionContext.messageHistory
+* @returns Formatted string to prepend to the prompt, or empty string if no history
+*/
+function formatMessageHistory(history) {
+	if (!history || history.length === 0) return "";
+	return `${formatMessageHistoryAsTranscript(history)}\n\n`;
+}
+
+//#endregion
+//#region src/utils/buildUserInputs.ts
+/**
+* User input assembly utilities for Codex App-Server turn/start.
+*
+* Builds the `input` array expected by `turn/start` from a normalized
+* `MessageHandle`, inserting history, merged context, turn context, and
+* content blocks in the correct order.
+*/
+/**
+* Assemble the `input` array for a `turn/start` request from a message handle.
+*
+* Ordering: outermost → innermost is
+* `message_history` → `merged_context` → `turn_context` → user text and blocks.
+* @param messageHandle - The message handle carrying user input and context
+* @param mergedContent - Optional array of prior message text merged into this turn
+* @returns Ordered array of `UserInput` items for `turn/start`
+*/
+function buildUserInputs(messageHandle, mergedContent) {
+	const messageContent = messageHandle.message;
+	const userInputs = [];
+	const historyPrefix = formatMessageHistory(messageHandle.messageHistory);
+	if (historyPrefix) userInputs.push({
+		type: "text",
+		text: `[CONVERSATION HISTORY]\n${historyPrefix}[END CONVERSATION HISTORY]\n\n`
+	});
+	if (mergedContent && mergedContent.length > 0) {
+		const mergedText = `[MERGED CONTEXT FROM PREVIOUS MESSAGES]\n${mergedContent.join("\n")}\n[END MERGED CONTEXT]\n\n`;
+		userInputs.push({
+			type: "text",
+			text: mergedText
+		});
+	}
+	const contextText = formatContextBlocksAsText(serializeTurnContext(messageHandle.turnContext));
+	if (contextText) userInputs.push({
+		type: "text",
+		text: contextText
+	});
+	for (const block of messageContent.blocks) {
+		const input = convertBlockToUserInput(block);
+		if (input) userInputs.push(input);
+	}
+	if (userInputs.length === 0 && messageContent.message) userInputs.push({
+		type: "text",
+		text: messageContent.message
+	});
+	return userInputs;
+}
+
+//#endregion
+//#region src/connector/turn-flow-handlers.ts
+/**
+* Maps canonical {@link AIReasoningLevel} values to Codex protocol {@link CodexReasoningEffort} strings.
+* @param level - Canonical reasoning level (must not be `'none'`)
+* @returns Codex-native effort string
+*/
+function mapToCodexEffort(level) {
+	return level === "extra-high" ? "xhigh" : level;
+}
+/**
+* Launch the ACP `thread/start` request, await the corresponding `thread/started`
+* notification, and populate the connector's `adapterSessionId`.
+*
+* A deferred promise is created before the request so the notification handler
+* can resolve it even if it fires before `await threadStartedPromise` is reached.
+* On error the deferred is cleared to prevent `getAdapterSessionId()` from hanging.
+* @param ctx - Turn flow context
+*/
+async function startThread(ctx) {
+	let resolve;
+	const threadStartedPromise = new Promise((res) => {
+		resolve = res;
+	});
+	ctx.setThreadStartedDeferred({
+		promise: threadStartedPromise,
+		resolve
+	});
+	try {
+		const dynamicTools = await fetchToolsForCodex(ctx.adapterId, ctx.adapterName);
+		const threadStartParams = {
+			model: ctx.getModel() ?? null,
+			modelProvider: null,
+			cwd: ctx.cwd ?? null,
+			approvalPolicy: ctx.getApprovalPolicy() ?? null,
+			sandbox: ctx.getSandboxMode() ?? null,
+			config: null,
+			baseInstructions: ctx.resolveSystemPrompt(),
+			developerInstructions: null,
+			experimentalRawEvents: false,
+			dynamicTools: dynamicTools.length > 0 ? dynamicTools : void 0
+		};
+		await ctx.getJsonRpcClient().request("thread/start", threadStartParams);
+		const threadId = await threadStartedPromise;
+		ctx.setAdapterSessionId(threadId);
+		ctx.setThreadStartedDeferred(void 0);
+	} catch (error) {
+		ctx.setThreadStartedDeferred(void 0);
+		throw error;
+	}
+}
+/**
+* Send a single `turn/start` request and wire the active turn.
+*
+* Creates a new {@link CodexAppServerTurn}, assigns it as the active turn, resets
+* the message accumulator, and fires the ACP `turn/start` request with the
+* current model and reasoning effort.
+* @param ctx - Turn flow context
+* @param messageHandle - Handle for the message being dispatched
+* @param mergedContent - Optional content lines merged from superseded handles
+*/
+async function startTurn(ctx, messageHandle, mergedContent) {
+	const thread = ctx.getThread();
+	if (!thread?.threadId) throw new Error("Cannot start turn: thread not started");
+	ctx.setCurrentTurn(new CodexAppServerTurn(ctx.bus, ctx.adapterId, ctx.adapterName, ctx.agentId, thread.threadId, messageHandle));
+	ctx.setPendingMessageHandle(messageHandle);
+	ctx.setAgentMessageContent("");
+	await ctx.getCurrentTurn().start();
+	const userInputs = buildUserInputs(messageHandle, mergedContent);
+	const effort = ctx.getReasoningEffort();
+	await ctx.getJsonRpcClient().request("turn/start", {
+		threadId: thread.threadId,
+		input: userInputs,
+		cwd: null,
+		approvalPolicy: null,
+		sandboxPolicy: null,
+		model: ctx.getModel() ?? null,
+		effort: effort !== void 0 && effort !== "none" ? mapToCodexEffort(effort) : null,
+		summary: null,
+		outputSchema: null
+	});
+}
+/**
+* Drain the message queue, dispatching the next eligible message as a new turn.
+*
+* Late-arriving `immediate` messages (arriving after a turn has already completed)
+* are rejected and the queue is re-drained to unblock any remaining entries.
+* @param ctx - Turn flow context
+*/
+async function processQueue(ctx) {
+	if (ctx.getCurrentTurn() && !ctx.getCurrentTurn().isCompleted()) return;
+	const nextMessage = ctx.messageQueue.peek();
+	if (!nextMessage) return;
+	if (nextMessage.deliveryMode === "immediate" && ctx.getLastResult() !== null) {
+		ctx.messageQueue.dequeue();
+		nextMessage.markCompleted({ outcome: "rejected" });
+		await processQueue(ctx);
+		if (!ctx.getCurrentTurn() && ctx.messageQueue.isEmpty()) await ctx.updateProcessingState("idle");
+		return;
+	}
+	const message = ctx.messageQueue.dequeue();
+	if (!message) return;
+	await startTurn(ctx, message);
+	if (!ctx.messageQueue.isEmpty()) await processQueue(ctx);
+}
+/**
+* Handle the `thread/started` notification from the Codex server.
+*
+* Resolves the deferred thread-started promise, sets the adapter session ID,
+* creates and registers the {@link CodexAppServerThread}, and fires the thread
+* lifecycle handler.
+* @param ctx - Turn flow context
+* @param notification - Parsed notification payload
+*/
+async function onThreadStarted(ctx, notification) {
+	const threadId = extractThreadId(notification);
+	ctx.setAdapterSessionId(threadId);
+	ctx.getThreadStartedDeferred()?.resolve(threadId);
+	ctx.setThread(new CodexAppServerThread({
+		bus: ctx.bus,
+		adapterId: ctx.adapterId,
+		agentId: ctx.agentId
+	}));
+	await ctx.getThread().handleThreadStarted(threadId);
+}
+/**
+* Handle the `turn/completed` notification from the Codex server.
+*
+* Manages the superseded-message / merged-message fast path (when an `immediate`
+* message is waiting), then settles the pending handle with its outcome. Drains
+* the queue or transitions to idle when no further messages are queued.
+* @param ctx - Turn flow context
+* @param _notification - Parsed notification payload (currently unused)
+*/
+async function onTurnCompleted(ctx, _notification) {
+	if (!ctx.getCurrentTurn()) return;
+	await ctx.getCurrentTurn().handleTurnCompleted();
+	const immediateMsg = ctx.messageQueue.findImmediate();
+	if (immediateMsg && ctx.getPendingMessageHandle()) {
+		ctx.messageQueue.removeImmediate(immediateMsg);
+		const mergedContent = [];
+		const currentHandle = ctx.getPendingMessageHandle();
+		if (currentHandle.message.message) mergedContent.push(currentHandle.message.message);
+		currentHandle.supersededBy = immediateMsg.messageId;
+		currentHandle.markCompleted({
+			outcome: "superseded",
+			supersededBy: immediateMsg.messageId
+		});
+		const enqueuedHandles = ctx.messageQueue.drainEnqueued();
+		for (const handle of enqueuedHandles) {
+			if (handle.message.message) mergedContent.push(handle.message.message);
+			handle.supersededBy = immediateMsg.messageId;
+			handle.markCompleted({
+				outcome: "merged",
+				mergedInto: immediateMsg.messageId
+			});
+		}
+		ctx.setLastResult({
+			outcome: "superseded",
+			supersededBy: immediateMsg.messageId
+		});
+		ctx.setPendingMessageHandle(void 0);
+		ctx.setCurrentTurn(void 0);
+		await ctx.updateProcessingState("turn_finished");
+		await ctx.updateProcessingState("processing_finished");
+		await startTurn(ctx, immediateMsg, mergedContent);
+		return;
+	}
+	const pendingHandle = ctx.getPendingMessageHandle();
+	if (pendingHandle) {
+		const turnId = ctx.getCurrentTurn()?.getTurnId();
+		const threadId = ctx.getThread()?.threadId;
+		const agentMessageContent = ctx.getAgentMessageContent();
+		if (agentMessageContent && threadId && turnId) await ctx.emit(CodexAppServerSubjects.agent_message, {
+			threadId,
+			turnId,
+			message: agentMessageContent,
+			timestamp: Date.now()
+		});
+		const result = {
+			outcome: "completed",
+			result: { message: agentMessageContent || "(Empty response)" }
+		};
+		pendingHandle.markCompleted(result);
+		ctx.setLastResult(result);
+		ctx.setPendingMessageHandle(void 0);
+	}
+	ctx.setCurrentTurn(void 0);
+	await ctx.updateProcessingState("turn_finished");
+	await ctx.updateProcessingState("processing_finished");
+	if (!ctx.messageQueue.isEmpty()) await processQueue(ctx);
+	else await ctx.updateProcessingState("idle");
+}
+
+//#endregion
+//#region src/connector/connector.ts
+var CodexAppServerConnector = class extends AIAgentConnector {
+	/** Lazy: initialised in initializeConnection(); public methods access via getJsonRpcClient(). */
+	jsonRpcClient;
+	/** Injected transport for tests; null means "create from subprocess on first connect". */
+	_injectedTransport;
+	/** Injected JSON-RPC client for tests; bypasses subprocess creation entirely. */
+	_injectedJsonRpcClient;
+	/** Transport owned by this connector and safe to tear down after partial startup failures. */
+	ownedTransport;
+	messageQueue = new UserMessageQueue();
+	thread;
+	currentTurn;
+	isConnected = false;
+	/** In-flight connection initialization promise for single-flight deduplication. */
+	initConnectionInflight = { promise: void 0 };
+	/** Handlers are registered once per client instance to avoid duplicate listeners on retries. */
+	clientHandlersRegistered = false;
+	isTerminated = false;
+	agentMessageContent = "";
+	notificationQueue = Promise.resolve();
+	threadStartedDeferred;
+	_approvalPolicy;
+	_sandboxMode;
+	_reasoningEffort;
+	commandExecutionByItemId = /* @__PURE__ */ new Map();
+	dynamicToolCallByItemId = /* @__PURE__ */ new Map();
+	/** Pending resolvers for {@link waitForCommandInfo}, keyed by itemId. */
+	commandInfoWaiters = /* @__PURE__ */ new Map();
+	disabledNativeTools = /* @__PURE__ */ new Set();
+	/**
+	* Stable context object passed to connection-manager module functions.
+	* All state access is via closures over `this` so the object is never stale.
+	*/
+	connCtx;
+	/**
+	* Stable context object passed to turn-flow-handlers module functions.
+	* All state access is via closures over `this` so the object is never stale.
+	*/
+	turnCtx;
+	constructor(config) {
+		super({
+			bus: config.bus,
+			adapterId: config.adapterId,
+			adapterName: config.adapterName ?? "codex-app-server",
+			agentId: config.agentId,
+			model: config.model,
+			cwd: config.cwd,
+			env: config.env,
+			onMessageSent: config.onMessageSent,
+			toolLedger: config.toolLedger,
+			reasoningEffort: config.reasoningEffort,
+			clientId: config.clientId,
+			harnessId: config.harnessId,
+			providerContext: config.providerContext
+		});
+		const fullConfig = config;
+		this._approvalPolicy = fullConfig.providerConfig?.approvalPolicy ?? fullConfig.approvalPolicy;
+		this._sandboxMode = fullConfig.providerConfig?.sandboxMode ?? fullConfig.sandboxMode;
+		this._reasoningEffort = fullConfig.providerConfig?.reasoningEffort ?? fullConfig.reasoningEffort;
+		this.currentReasoningEffort = this._reasoningEffort;
+		this._injectedJsonRpcClient = config.jsonRpcClient;
+		this._injectedTransport = config.transport;
+		if (config.jsonRpcClient) this.jsonRpcClient = config.jsonRpcClient;
+		this.connCtx = this.buildConnectionContext();
+		this.turnCtx = this.buildTurnFlowContext();
+	}
+	buildConnectionContext() {
+		return {
+			getJsonRpcClient: () => this.jsonRpcClient,
+			setJsonRpcClient: (client) => {
+				this.jsonRpcClient = client;
+			},
+			getInjectedJsonRpcClient: () => this._injectedJsonRpcClient,
+			getInjectedTransport: () => this._injectedTransport,
+			getOwnedTransport: () => this.ownedTransport,
+			setOwnedTransport: (transport) => {
+				this.ownedTransport = transport;
+			},
+			getIsConnected: () => this.isConnected,
+			setIsConnected: (value) => {
+				this.isConnected = value;
+			},
+			setClientHandlersRegistered: (value) => {
+				this.clientHandlersRegistered = value;
+			},
+			setDisabledNativeTools: (tools) => {
+				this.disabledNativeTools = tools;
+			},
+			cwd: this.cwd,
+			env: this.env,
+			adapterName: this.adapterName,
+			providerContext: this.config.providerContext,
+			clientId: this.config.clientId,
+			harnessId: this.config.harnessId,
+			bus: this.config.bus,
+			registerClientHandlers: () => this.registerClientHandlers(),
+			handleError: (error, terminate) => this.handleError(error, terminate)
+		};
+	}
+	buildTurnFlowContext() {
+		return {
+			getCurrentTurn: () => this.currentTurn,
+			setCurrentTurn: (turn) => {
+				this.currentTurn = turn;
+			},
+			getThread: () => this.thread,
+			setThread: (thread) => {
+				this.thread = thread;
+			},
+			getAgentMessageContent: () => this.agentMessageContent,
+			setAgentMessageContent: (content) => {
+				this.agentMessageContent = content;
+			},
+			getPendingMessageHandle: () => this.pendingMessageHandle,
+			setPendingMessageHandle: (handle) => {
+				this.pendingMessageHandle = handle;
+			},
+			setLastResult: (result) => {
+				this.lastResult = result;
+			},
+			getLastResult: () => this.lastResult,
+			setAdapterSessionId: (id) => {
+				this.adapterSessionId = id;
+			},
+			getThreadStartedDeferred: () => this.threadStartedDeferred,
+			setThreadStartedDeferred: (deferred) => {
+				this.threadStartedDeferred = deferred;
+			},
+			messageQueue: this.messageQueue,
+			getJsonRpcClient: () => this.getJsonRpcClient(),
+			emit: this.emit.bind(this),
+			updateProcessingState: this.updateProcessingState.bind(this),
+			agentId: this.agentId,
+			adapterId: this.adapterId,
+			adapterName: this.adapterName,
+			bus: this.config.bus,
+			getModel: () => this.model,
+			getReasoningEffort: () => this.currentReasoningEffort,
+			getApprovalPolicy: () => this._approvalPolicy,
+			getSandboxMode: () => this._sandboxMode,
+			resolveSystemPrompt: () => this.resolveSystemPrompt(),
+			cwd: this.cwd
+		};
+	}
+	get approvalPolicy() {
+		return this._approvalPolicy;
+	}
+	get sandboxMode() {
+		return this._sandboxMode;
+	}
+	get reasoningEffort() {
+		return this._reasoningEffort;
+	}
+	/**
+	* Resolve any pending {@link waitForCommandInfo} promise for `itemId`.
+	* Called by the `item/started` lifecycle path after populating `commandExecutionByItemId`.
+	* @param itemId - Item now available in commandExecutionByItemId
+	* @param info - Command execution metadata just written to the cache
+	*/
+	notifyCommandInfoReady(itemId, info) {
+		const resolve = this.commandInfoWaiters.get(itemId);
+		if (resolve) {
+			this.commandInfoWaiters.delete(itemId);
+			resolve(info);
+		}
+	}
+	/**
+	* Return `commandExecutionByItemId` entry for `itemId` immediately if present,
+	* otherwise wait up to 5 seconds for `item/started` to populate it.
+	* Returns `undefined` on timeout so callers can degrade gracefully.
+	* @param itemId - Item ID to wait for
+	* @returns Command execution metadata, or `undefined` on timeout
+	*/
+	waitForCommandInfo(itemId) {
+		const existing = this.commandExecutionByItemId.get(itemId);
+		if (existing) return Promise.resolve(existing);
+		return new Promise((resolve) => {
+			const timeout = setTimeout(() => {
+				this.commandInfoWaiters.delete(itemId);
+				resolve(void 0);
+			}, 5e3);
+			this.commandInfoWaiters.set(itemId, (info) => {
+				clearTimeout(timeout);
+				resolve(info);
+			});
+		});
+	}
+	resolveSystemPrompt() {
+		if (this.systemPrompt === void 0) return null;
+		return typeof this.systemPrompt === "string" ? this.systemPrompt : this.systemPrompt.content;
+	}
+	enqueueNotification(handler) {
+		this.notificationQueue = this.notificationQueue.then(handler).catch((error) => {
+			console.error("[CodexAppServerConnector] Notification handler error:", error);
+		});
+	}
+	getJsonRpcClient() {
+		if (!this.jsonRpcClient) throw new Error("JSON-RPC client not initialized");
+		return this.jsonRpcClient;
+	}
+	registerClientHandlers() {
+		if (this.clientHandlersRegistered) return;
+		const client = this.getJsonRpcClient();
+		const tfCtx = this.turnCtx;
+		registerNotificationHandlers({
+			client,
+			enqueueNotification: this.enqueueNotification.bind(this),
+			onThreadStarted: (n) => onThreadStarted(tfCtx, n),
+			consumeTurnNumber: this.consumeTurnNumber.bind(this),
+			getCurrentTurn: () => this.currentTurn,
+			emit: this.emit.bind(this),
+			commandExecutionByItemId: this.commandExecutionByItemId,
+			dynamicToolCallByItemId: this.dynamicToolCallByItemId,
+			updateProcessingState: this.updateProcessingState.bind(this),
+			appendAgentMessageDelta: (delta) => {
+				this.agentMessageContent += delta;
+			},
+			onTurnCompleted: (n) => onTurnCompleted(tfCtx, n),
+			getThread: () => this.thread,
+			handleAsyncError: (error) => this.handleError(error),
+			onCommandInfoReady: this.notifyCommandInfoReady.bind(this)
+		});
+		registerServerRequestHandler({
+			client,
+			agentId: this.agentId,
+			cwd: this.cwd ?? "",
+			commandExecutionByItemId: this.commandExecutionByItemId,
+			requestToolApproval: this.requestToolApproval.bind(this),
+			handleError: this.handleError.bind(this),
+			getDisabledNativeTools: () => this.disabledNativeTools,
+			handleDynamicToolCallRequest: this.handleDynamicToolCallRequest.bind(this),
+			waitForCommandInfo: this.waitForCommandInfo.bind(this)
+		});
+		this.clientHandlersRegistered = true;
+	}
+	async handleDynamicToolCallRequest(params) {
+		return handleDynamicToolCallApprovalRequest(params, {
+			requestToolApproval: this.requestToolApproval.bind(this),
+			emit: this.emit.bind(this),
+			sessionId: this.sessionId,
+			agentId: this.agentId,
+			adapterId: this.adapterId,
+			adapterName: this.adapterName,
+			dynamicToolCallByItemId: this.dynamicToolCallByItemId,
+			toolLedger: this.config.toolLedger,
+			currentTurnNumber: this.currentTurnNumber
+		});
+	}
+	async initialize(options) {
+		this.captureSystemPrompt(options?.systemPrompt);
+		if (!this.isConnected) await initializeConnection(this.connCtx, this.initConnectionInflight);
+		if (!this.thread) await startThread(this.turnCtx);
+	}
+	async start(message, options) {
+		this.captureSystemPrompt(options?.systemPrompt);
+		const messageHandle = await this.sendMessage(message, options);
+		return {
+			adapterSessionId: await this.getAdapterSessionId(),
+			messageHandle,
+			agentId: this.agentId
+		};
+	}
+	async sendMessage(message, options) {
+		if (!this.isConnected) await initializeConnection(this.connCtx, this.initConnectionInflight);
+		if (!this.thread) await startThread(this.turnCtx);
+		const handle = this.createMessageHandle(message, options);
+		if (this.getProcessingState() === "idle") await this.updateProcessingState("active");
+		this.messageQueue.enqueue(handle);
+		if (!this.currentTurn || this.currentTurn.isCompleted()) await processQueue(this.turnCtx);
+		return handle;
+	}
+	/**
+	* Codex supports per-turn model switching via `turn/start`.
+	* The caller updates `this.model` after this returns true.
+	* @param _newModel - The model identifier (unused — read from `this.model` at turn start)
+	* @returns Always `true`
+	*/
+	async changeModelInPlace(_newModel) {
+		return true;
+	}
+	/**
+	* Codex passes reasoning effort per-turn via `turn/start`; `startTurn` reads
+	* `this.currentReasoningEffort` at send time, so no SDK reconfiguration is needed.
+	* @param _newLevel - Unused — read from `this.currentReasoningEffort` at turn start
+	* @returns Always `true`
+	*/
+	async changeReasoningInPlace(_newLevel) {
+		return true;
+	}
+	async interrupt() {
+		if (!this.currentTurn?.getTurnId()) return;
+		await this.getJsonRpcClient().request("turn/interrupt", { turnId: this.currentTurn.getTurnId() });
+	}
+	async getAdapterSessionId() {
+		if (this.adapterSessionId) return this.adapterSessionId;
+		if (this.threadStartedDeferred) return this.threadStartedDeferred.promise;
+		throw new Error("Thread not started");
+	}
+	async complete() {
+		while (this.getProcessingState() !== "idle") await this.onceProcessingStateChanged();
+		return this.lastResult;
+	}
+	abort() {
+		if (this.isTerminated) return;
+		this.isTerminated = true;
+		this.jsonRpcClient?.close();
+	}
+	async close() {
+		if (this.isTerminated) return;
+		this.isTerminated = true;
+		await this.archiveThread();
+		this.jsonRpcClient?.close();
+	}
+	async archiveThread() {
+		const threadId = this.thread?.threadId;
+		if (!threadId) return;
+		const archiveRequest = this.jsonRpcClient?.request("thread/archive", { threadId });
+		if (!archiveRequest) return;
+		try {
+			await Promise.race([archiveRequest, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("archive timeout")), 2e3))]);
+		} catch {}
+	}
+	acceptsImmediate() {
+		if (!this.currentTurn) return true;
+		return this.currentTurn.canAcceptImmediate();
+	}
+	handleError(error, terminate = false) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		if (this.pendingMessageHandle && !this.pendingMessageHandle.isProcessed) this.lastResult = {
+			outcome: "error",
+			error: err
+		};
+		super.handleError(err, terminate);
+	}
+};
+
+//#endregion
+//#region src/constants.ts
+/** Adapter name constant for consistent identification */
+const CodexAppServerAdapterName = "codex-app-server";
+/** Default model for Codex App-Server adapter */
+const DefaultModel = "gpt-5.1-codex-mini";
+/** Default provider for Codex App-Server adapter */
+const DefaultProvider = "openai";
+/** Default timeout configuration for Codex App-Server adapter */
+const DEFAULT_TIMEOUTS = {
+	initialization: 3e4,
+	acknowledgement: 3e4,
+	completion: 6e4,
+	toolApproval: 5e3,
+	eventWait: 3e3
+};
+
+//#endregion
+//#region src/schemas.ts
+/**
+* Approval policy enum values for Codex app-server.
+* Maps to AskForApproval in app-server protocol.
+* - 'untrusted': Always ask for approval (most restrictive)
+* - 'on-failure': Ask for approval only if command fails
+* - 'on-request': Ask for approval when command requests escalated permissions
+* - 'never': Never ask for approval (least restrictive)
+*/
+const ApprovalPolicyValues = [
+	"untrusted",
+	"on-failure",
+	"on-request",
+	"never"
+];
+/**
+* Sandbox mode enum values for Codex app-server.
+* Maps to SandboxMode in app-server protocol.
+* - 'read-only': Commands cannot write to filesystem
+* - 'workspace-write': Commands can write to workspace directories
+* - 'danger-full-access': Commands have full filesystem access
+*/
+const SandboxModeValues = [
+	"read-only",
+	"workspace-write",
+	"danger-full-access"
+];
+/**
+* Reasoning effort enum values for Codex app-server.
+* Maps to ReasoningEffort in app-server protocol.
+*/
+const ReasoningEffortValues = [
+	"low",
+	"medium",
+	"high"
+];
+/**
+* Zod schema for Codex app-server provider-specific configuration.
+*
+* Used for:
+* 1. Type-safe config resolution
+* 2. Serialization to JSON Schema for web-ui form generation
+* 3. Runtime validation
+*
+* Note: `cwd` and `model` come from the adapter options (BaseAgentConnectorConfig),
+* not from this provider config. This schema only contains provider-specific settings.
+*/
+const CodexAppServerProviderConfigSchema = z.object({
+	/**
+	* Approval policy for tool execution.
+	*/
+	approvalPolicy: z.enum(ApprovalPolicyValues).default("on-request").meta({
+		title: "Approval Policy",
+		description: "How to handle tool approval requests"
+	}),
+	/**
+	* Sandbox mode for command execution.
+	*/
+	sandboxMode: z.enum(SandboxModeValues).default("read-only").meta({
+		title: "Sandbox Mode",
+		description: "Sandbox execution environment"
+	}),
+	/**
+	* Reasoning effort level.
+	*/
+	reasoningEffort: z.enum(ReasoningEffortValues).optional().meta({
+		title: "Reasoning Effort",
+		description: "Level of reasoning effort for the model"
+	})
+});
+
+//#endregion
+//#region src/config.ts
+const CodexAppServerConfig = createAdapterConfigFactory(() => ({
+	adapterName: CodexAppServerAdapterName,
+	adapterDefaults: {
+		reasoningEffort: "low",
+		providerConfig: {
+			approvalPolicy: "untrusted",
+			sandboxMode: "workspace-write"
+		}
+	},
+	schema: CodexAppServerProviderConfigSchema,
+	adapterDefinition: { defaultTimeouts: DEFAULT_TIMEOUTS },
+	protocol: "openai"
+}));
+
+//#endregion
+//#region src/adapter.ts
+/**
+* Codex App-Server Adapter - Domain-level adapter using the three-layer architecture.
+*
+* Architecture:
+* ```
+* CodexAppServerAdapter extends AIAdapter
+*     -> creates via agentFactory()
+* CodexAppServerAgent extends AIAgent
+*     -> receives connector via connectorFactory()
+* CodexAppServerConnector extends AIAgentConnector
+* ```
+*
+* Responsibilities:
+* - Handle adapter.startAgent RPC (inherited from AIAdapter)
+* - Provide agent and connector factories for instance creation
+* - Emit adapter.initialized and adapter.session.created events
+* - Manage agent lifecycle (tracking, disposal)
+* @example
+* ```typescript
+* // Using the class directly
+* const adapter = new CodexAppServerAdapter();
+* await adapter.init();
+*
+* // Using the convenience factory
+* const adapter = await createCodexAppServerAdapter();
+* ```
+*/
+var CodexAppServerAdapter = class extends AIAdapter {
+	constructor(config) {
+		super({
+			name: CodexAppServerAdapterName,
+			capabilities: [
+				"tools",
+				"streaming",
+				"systemPrompt:override",
+				"systemPrompt:append"
+			],
+			nativeTools: ["bash", "patch"],
+			...config,
+			namespace: CodexAppServerNamespace,
+			agentFactory: (agentConfig) => {
+				return new CodexAppServerAgent(agentConfig);
+			},
+			configFactory: CodexAppServerConfig.getConfig,
+			connectorFactory: (fullConfig) => new CodexAppServerConnector(fullConfig),
+			definitionProviders: config?.definitionProviders
+		});
+	}
+};
+/**
+* Factory function to create and initialize a Codex App-Server adapter.
+*
+* Convenience wrapper that creates the adapter and calls init() for you.
+* @param config - Optional adapter configuration
+* @returns Initialized CodexAppServerAdapter instance
+* @example
+* ```typescript
+* const adapter = await createCodexAppServerAdapter();
+*
+* // Adapter is ready to handle requests via bus
+* // e.g., MakaioBus.request(AdapterSubjects.startAgent, { adapterId: adapter.adapterId, ... })
+* ```
+*/
+async function createCodexAppServerAdapter(config) {
+	const adapter = new CodexAppServerAdapter(config);
+	await adapter.init();
+	return adapter;
+}
+
+//#endregion
+//#region src/event-normalizers.ts
+/**
+* Normalize app-server event to canonical AgentSubjects.
+*
+* Transforms app-server protocol notifications to global agent events.
+* Returns array of normalized events (some notifications may map to multiple).
+* @param notification - The server notification from app-server
+* @param context - Normalization context with session/adapter info
+* @returns Array of normalized events (may be empty for unhandled types)
+*/
+function normalizeAppServerEvent(notification, context) {
+	const { method, params } = notification;
+	if (method === "item/agentMessage/delta") return [normalizeAgentMessageDelta(params, context)];
+	if (method === "item/started") return normalizeItemStarted(params, context);
+	if (method === "item/commandExecution/outputDelta") return [normalizeCommandOutputDelta(params, context)];
+	if (method === "item/reasoning/textDelta") return [normalizeReasoningDelta(params, context)];
+	if (method === "thread/tokenUsage/updated") return [normalizeTokenUsage(params, context)];
+	if (method === "turn/completed") return [normalizeTurnCompleted(params, context)];
+	return [];
+}
+/**
+* Normalize agent message delta to agent.message_delta subject.
+* @param params - The agent message delta notification
+* @param ctx - Normalization context
+* @returns Normalized event for message_delta
+*/
+function normalizeAgentMessageDelta(params, ctx) {
+	return {
+		subject: AgentSubjects.message_delta,
+		payload: {
+			...ctx,
+			text: params.delta
+		}
+	};
+}
+/**
+* Normalize item started to appropriate subject based on item type.
+* @param params - The item started notification
+* @param ctx - Normalization context
+* @returns Array of normalized events (may be empty for unhandled types)
+*/
+function normalizeItemStarted(params, ctx) {
+	const { item } = params;
+	if (item.type === "agentMessage") return [{
+		subject: AgentSubjects.message_delta,
+		payload: {
+			...ctx,
+			text: ""
+		}
+	}];
+	if (item.type === "commandExecution") return [{
+		subject: AgentSubjects.tool.started,
+		payload: {
+			...ctx,
+			toolName: "bash",
+			toolCallId: item.id
+		}
+	}];
+	if (item.type === "fileChange") return [{
+		subject: AgentSubjects.tool.started,
+		payload: {
+			...ctx,
+			toolName: "patch",
+			toolCallId: item.id
+		}
+	}];
+	if (item.type === "mcpToolCall") return [{
+		subject: AgentSubjects.tool.started,
+		payload: {
+			...ctx,
+			toolName: `${item.server}:${item.tool}`,
+			toolCallId: item.id
+		}
+	}];
+	return [];
+}
+/**
+* Normalize command output delta to agent.tool.output subject.
+* @param params - The command output delta notification
+* @param ctx - Normalization context
+* @returns Normalized event for tool output
+*/
+function normalizeCommandOutputDelta(params, ctx) {
+	return {
+		subject: AgentSubjects.tool.output,
+		payload: {
+			...ctx,
+			output: params.delta,
+			toolCallId: params.itemId
+		}
+	};
+}
+/**
+* Normalize reasoning delta to agent.reasoning_delta subject.
+* @param params - The reasoning text delta notification
+* @param ctx - Normalization context
+* @returns Normalized event for reasoning delta
+*/
+function normalizeReasoningDelta(params, ctx) {
+	return {
+		subject: AgentSubjects.reasoning_delta,
+		payload: {
+			...ctx,
+			content: params.delta
+		}
+	};
+}
+/**
+* Derive provider from model name.
+* @param model - The model name
+* @returns The provider identifier
+*/
+function deriveProvider(model) {
+	if (model.startsWith("claude")) return "anthropic";
+	if (model.startsWith("gpt") || model.startsWith("o1") || model.startsWith("o3")) return "openai";
+	return DefaultProvider;
+}
+/**
+* Normalize token usage to agent.usage subject.
+* @param params - The token usage updated notification
+* @param ctx - Normalization context
+* @returns Normalized event for usage
+*/
+function normalizeTokenUsage(params, ctx) {
+	const { last } = params.tokenUsage;
+	const model = ctx.model ?? "gpt-5.1-codex-mini";
+	const provider = deriveProvider(model);
+	return {
+		subject: AgentSubjects.usage,
+		payload: {
+			...ctx,
+			provider,
+			model,
+			inputTokens: last.inputTokens,
+			inputCachedTokens: last.cachedInputTokens,
+			outputTokens: last.outputTokens,
+			reasoningTokens: last.reasoningOutputTokens,
+			totalTokens: last.totalTokens,
+			costUnits: last.totalTokens,
+			costUnitType: "tokens"
+		}
+	};
+}
+/**
+* Normalize turn completed to agent.complete subject.
+* @param params - The turn completed notification
+* @param ctx - Normalization context
+* @returns Normalized event for completion
+*/
+function normalizeTurnCompleted(params, ctx) {
+	return {
+		subject: AgentSubjects.complete,
+		payload: { ...ctx }
+	};
+}
+
+//#endregion
+//#region src/protocol/generated/v2/index.ts
+var v2_exports = /* @__PURE__ */ __exportAll({});
+
+//#endregion
+//#region src/provider.ts
+/**
+* Provider IDs and preset configuration for the Codex App-Server adapter.
+*
+* Provider compatibility is declared by stable definition ID — the adapter
+* subsystem resolves each ID to a full ProviderDefinitionInput from the
+* provider registry at boot time.
+*/
+const providerIds = ["openai-codex"];
+/**
+* Default provider id to use when no provider is explicitly configured.
+*/
+const defaultPresetId = "openai-codex";
+/** Provider id used for conformance tests (same as host default for this adapter). */
+const testPresetId = defaultPresetId;
+
+//#endregion
+//#region src/index.ts
+const createTestConfig = async (options) => {
+	const { scopedBus } = CodexAppServerNamespace;
+	const bus = await scopedBus();
+	const testPreset = resolveConformanceTestPreset({
+		adapterName: CodexAppServerAdapterName,
+		defaultProviderId: testPresetId,
+		providerIds,
+		providerDefinitions: options?.providerDefinitions,
+		reasoningEffort: "low"
+	});
+	return {
+		createConnector: async (connectorOptions) => new CodexAppServerConnector(await CodexAppServerConfig.getConfig(resolveTestConfig(connectorOptions, bus, testPreset.provider, testPreset.providers))),
+		bus,
+		registerToolApprovalHandler,
+		capabilities: {
+			supportsReplace: true,
+			supportsInterrupt: true,
+			supportsUsageMetrics: true
+		},
+		options: {
+			defaultTimeout: 45e3,
+			primaryModel: testPreset.primaryModel,
+			secondaryModel: testPreset.secondaryModel
+		},
+		createAdapter: async (adapterOptions) => createCodexAppServerAdapter(adapterOptions),
+		adapterName: CodexAppServerAdapterName,
+		testProviderContext: testPreset.providerContext
+	};
+};
+
+//#endregion
+export { AgentMessageDeltaSchema, AgentMessageSchema, CodexAppServerAdapter, CodexAppServerAdapterName, CodexAppServerAgent, CodexAppServerConfig, CodexAppServerConnector, CodexAppServerNamespace, CodexAppServerProviderConfigSchema, CodexAppServerSubjects, CodexAppServerThread, CodexAppServerTurn, CodexAppServerTurnStateSchema, DynamicToolCallApprovalRequestSchema, DynamicToolCallBeginSchema, DynamicToolCallEndSchema, ExecApprovalRequestSchema, ExecCommandBeginSchema, ExecCommandEndSchema, ExecCommandOutputDeltaSchema, FileChangeApprovalRequestSchema, FileChangeOutputDeltaSchema, ItemCompletedSchema, ItemStartedSchema, ReasoningDeltaSchema, ReasoningSchema, ThreadCompletedSchema, ThreadStartedSchema, TokenUsageSchema, TurnCompletedSchema, TurnStartedSchema, TurnStateChangedSchema, TurnStepFinishedSchema, TurnStepStartedSchema, createCodexAppServerAdapter, createJsonRpcClient, createStdioTransport, createTestConfig, formatMessageHistory, fromGlobalToolApproval, normalizeAppServerEvent, registerToolApprovalHandler, toGlobalFileApproval, toGlobalToolApproval, v2_exports as v2 };