@jrkropp/codex-js 0.1.1 → 0.1.3

package/dist/chunk-V4BMZWBM.js

@@ -0,0 +1,2401 @@
+import { asThreadId, SteerInputErrorKind, EmptyMcpConnectionManager, SteerInputError, defaultSessionConfiguration, Session, RegularTask, runTurn, CompactTask, run_compact_task } from './chunk-LWQNX4LI.js';
+import { ThreadSortKey, SortDirection, ThreadMemoryMode, ThreadEventPersistenceMode, LiveThread } from './chunk-CGBS37IU.js';
+import { clientRequestExperimentalReason, clientRequestSerializationScope, appServerTurnFromCoreTurn, threadTokenUsageFromTokenUsageInfo, threadHistoryToAppServerThread, buildThreadResumeResponseFromHistory, eventMsgToAppServerEvents, serverRequestResolvedNotification } from './chunk-2DZRMCI2.js';
+import { ThreadHistoryBuilder } from './chunk-DYLHN3HG.js';
+import { builtinCollaborationModePresets, normalizeCollaborationMode } from './chunk-SYPHCDRD.js';
+import { BaseInstructions } from './chunk-O44XP7LH.js';
+
+// src/upstream/codex-rs/app-server-transport/src/transport/mod.ts
+function parseJsonRpcTransportPayload(payload) {
+  let value;
+  if (typeof payload === "string") {
+    try {
+      value = JSON.parse(payload);
+    } catch {
+      return {
+        error: jsonRpcParseError("Parse error"),
+        id: null,
+        type: "invalid"
+      };
+    }
+  } else if (payload instanceof ArrayBuffer || ArrayBuffer.isView(payload)) {
+    const bytes = payload instanceof ArrayBuffer ? new Uint8Array(payload) : new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
+    try {
+      value = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      return {
+        error: jsonRpcParseError("Parse error"),
+        id: null,
+        type: "invalid"
+      };
+    }
+  } else {
+    value = payload;
+  }
+  return parseJsonRpcMessage(value);
+}
+function parseJsonRpcMessage(value) {
+  if (!isRecord(value)) {
+    return {
+      error: jsonRpcInvalidRequestError("Invalid JSON-RPC message"),
+      id: null,
+      type: "invalid"
+    };
+  }
+  const candidateId = requestIdFromValue(value.id);
+  const id = candidateId ?? null;
+  if (typeof value.method === "string") {
+    if (candidateId !== null) {
+      return {
+        message: jsonRpcRequest(value.method, candidateId, value.params),
+        type: "ok"
+      };
+    }
+    if (Object.prototype.hasOwnProperty.call(value, "id")) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC request id"),
+        id: null,
+        type: "invalid"
+      };
+    }
+    return {
+      message: jsonRpcNotification(value.method, value.params),
+      type: "ok"
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(value, "error")) {
+    if (!isJsonRpcErrorError(value.error)) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC error object"),
+        id,
+        type: "invalid"
+      };
+    }
+    return {
+      message: { error: value.error, id },
+      type: "ok"
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(value, "result")) {
+    if (candidateId === null) {
+      return {
+        error: jsonRpcInvalidRequestError("Invalid JSON-RPC response id"),
+        id: null,
+        type: "invalid"
+      };
+    }
+    return {
+      message: { id: candidateId, result: value.result },
+      type: "ok"
+    };
+  }
+  return {
+    error: jsonRpcInvalidRequestError("Invalid JSON-RPC message"),
+    id,
+    type: "invalid"
+  };
+}
+function parseServerTransportPayload(payload) {
+  const parsed = parseJsonRpcTransportPayload(payload);
+  if (parsed.type === "invalid") {
+    return parsed;
+  }
+  return {
+    message: serverTransportMessage(parsed.message),
+    type: "ok"
+  };
+}
+function parseClientTransportPayload(payload) {
+  const parsed = parseJsonRpcTransportPayload(payload);
+  if (parsed.type === "invalid") {
+    return parsed;
+  }
+  return {
+    message: clientTransportMessage(parsed.message),
+    type: "ok"
+  };
+}
+function serializeOutgoingMessage(message) {
+  return JSON.stringify(message);
+}
+function serializeJsonRpcResponse(id, result) {
+  return serializeOutgoingMessage({ id, result });
+}
+function serializeJsonRpcError(id, error) {
+  return JSON.stringify({ error, id });
+}
+function queuedOutgoingMessage(message, writeComplete) {
+  return { message, writeComplete };
+}
+function jsonRpcParseError(message) {
+  return { code: -32700, message };
+}
+function jsonRpcInvalidRequestError(message) {
+  return { code: -32600, message };
+}
+function jsonRpcInternalError(message) {
+  return { code: -32603, message };
+}
+function serverTransportMessage(message) {
+  if (isRequest(message)) {
+    return { request: message, type: "client_request" };
+  }
+  if (isNotification(message)) {
+    return {
+      notification: message,
+      type: "client_notification"
+    };
+  }
+  if (isError(message)) {
+    return { error: message, type: "error" };
+  }
+  return { response: message, type: "response" };
+}
+function clientTransportMessage(message) {
+  if (isRequest(message)) {
+    return { request: message, type: "server_request" };
+  }
+  if (isNotification(message)) {
+    return {
+      notification: message,
+      type: "server_notification"
+    };
+  }
+  if (isError(message)) {
+    return { error: message, type: "error" };
+  }
+  return { response: message, type: "response" };
+}
+function jsonRpcRequest(method, id, params) {
+  return params === void 0 ? { id, method } : { id, method, params };
+}
+function jsonRpcNotification(method, params) {
+  return params === void 0 ? { method } : { method, params };
+}
+function isRequest(message) {
+  return typeof message.method === "string" && Object.prototype.hasOwnProperty.call(message, "id");
+}
+function isNotification(message) {
+  return typeof message.method === "string" && !Object.prototype.hasOwnProperty.call(message, "id");
+}
+function isError(message) {
+  return Object.prototype.hasOwnProperty.call(message, "error");
+}
+function requestIdFromValue(value) {
+  return typeof value === "string" || typeof value === "number" ? value : null;
+}
+function isJsonRpcErrorError(value) {
+  return isRecord(value) && typeof value.code === "number" && typeof value.message === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/upstream/codex-rs/app-server/src/outgoing_message.ts
+var OutgoingMessageSender = class {
+  nextServerRequestId = 0;
+  requestIdToCallback = /* @__PURE__ */ new Map();
+  requestContexts = /* @__PURE__ */ new Map();
+  sendMessage;
+  constructor(options) {
+    this.sendMessage = options.send;
+  }
+  threadScoped(threadId) {
+    return new ThreadScopedOutgoingMessageSender(this, threadId, []);
+  }
+  threadScopedForConnections(threadId, connectionIds) {
+    return new ThreadScopedOutgoingMessageSender(this, threadId, connectionIds);
+  }
+  async sendServerNotification(notification, context, threadId, connectionIds) {
+    await this.sendMessage(notification, {
+      connectionIds,
+      context,
+      threadId: serverNotificationThreadId(notification) ?? threadId
+    });
+  }
+  async sendRequest(request, threadId = serverRequestThreadId(request), context, connectionIds) {
+    return this.sendRequestWithHandle(request, threadId, context, connectionIds).result;
+  }
+  sendRequestWithHandle(request, threadId = serverRequestThreadId(request), context, connectionIds) {
+    const requestWithId = request.id === void 0 ? { ...request, id: this.nextRequestId() } : request;
+    let rejectResult = () => {
+    };
+    const result = new Promise((resolve, reject) => {
+      rejectResult = reject;
+      this.requestIdToCallback.set(requestWithId.id, {
+        callback: (entry) => {
+          if (entry.type === "ok") {
+            resolve(entry.result);
+            return;
+          }
+          reject(entry.error);
+        },
+        connectionIds: connectionIds ?? null,
+        request: requestWithId,
+        threadId
+      });
+    });
+    void Promise.resolve(
+      this.sendMessage(requestWithId, {
+        connectionIds,
+        context,
+        threadId: threadId ?? void 0
+      })
+    ).catch((error) => {
+      this.requestIdToCallback.delete(requestWithId.id);
+      rejectResult(error);
+    });
+    return { request: requestWithId, result };
+  }
+  registerRequestContext(requestContext) {
+    this.requestContexts.set(connectionRequestKey(requestContext), requestContext);
+  }
+  requestContext(requestId) {
+    return this.requestContexts.get(connectionRequestKey(requestId)) ?? null;
+  }
+  async sendResponse(requestId, result, context) {
+    this.requestContexts.delete(connectionRequestKey(requestId));
+    await this.sendMessage(
+      { id: requestId.requestId, result },
+      { connectionIds: [requestId.connectionId], context }
+    );
+  }
+  async sendError(requestId, error, context) {
+    this.requestContexts.delete(connectionRequestKey(requestId));
+    await this.sendMessage(
+      { error, id: requestId.requestId },
+      { connectionIds: [requestId.connectionId], context }
+    );
+  }
+  async notifyClientResponse(id, result) {
+    const entry = this.takeRequestCallback(id);
+    entry?.callback({ result, type: "ok" });
+  }
+  async notifyClientError(id, error) {
+    const entry = this.takeRequestCallback(id);
+    entry?.callback({ error, type: "error" });
+  }
+  cancelRequest(id) {
+    return this.takeRequestCallback(id) !== null;
+  }
+  connectionClosed(connectionId) {
+    for (const [requestKey, requestContext] of this.requestContexts) {
+      if (requestContext.connectionId === connectionId) {
+        this.requestContexts.delete(requestKey);
+      }
+    }
+  }
+  cancelRequestsForThread(threadId, error) {
+    for (const [requestId, entry] of this.requestIdToCallback) {
+      if (entry.threadId !== threadId) {
+        continue;
+      }
+      this.requestIdToCallback.delete(requestId);
+      if (error) {
+        entry.callback({ error, type: "error" });
+      }
+    }
+  }
+  pendingRequestsForThread(threadId) {
+    return Array.from(this.requestIdToCallback.values()).filter((entry) => entry.threadId === threadId).map((entry) => entry.request).sort((left, right) => String(left.id).localeCompare(String(right.id)));
+  }
+  nextRequestId() {
+    const id = this.nextServerRequestId;
+    this.nextServerRequestId += 1;
+    return id;
+  }
+  takeRequestCallback(id) {
+    const entry = this.requestIdToCallback.get(id) ?? null;
+    this.requestIdToCallback.delete(id);
+    return entry;
+  }
+};
+var ThreadScopedOutgoingMessageSender = class {
+  constructor(outgoing, threadId, connectionIds = []) {
+    this.outgoing = outgoing;
+    this.threadId = threadId;
+    this.connectionIds = connectionIds;
+  }
+  outgoing;
+  threadId;
+  connectionIds;
+  sendRequest(request, context) {
+    return this.outgoing.sendRequest(
+      request,
+      this.threadId,
+      context,
+      this.connectionIds.length > 0 ? this.connectionIds : void 0
+    );
+  }
+  sendServerNotification(notification, context) {
+    return this.outgoing.sendServerNotification(
+      notification,
+      context,
+      this.threadId,
+      this.connectionIds.length > 0 ? this.connectionIds : void 0
+    );
+  }
+  sendResponse(requestId, result, context) {
+    return this.outgoing.sendResponse(requestId, result, context);
+  }
+  sendError(requestId, error, context) {
+    return this.outgoing.sendError(requestId, error, context);
+  }
+  abortPendingServerRequests(error) {
+    this.outgoing.cancelRequestsForThread(this.threadId, error);
+  }
+  pendingRequests() {
+    return this.outgoing.pendingRequestsForThread(this.threadId);
+  }
+};
+function outgoingMessageToAppServerEvent(message) {
+  if (isServerNotification(message)) {
+    return {
+      notification: message,
+      type: "server_notification"
+    };
+  }
+  if (isServerRequest(message)) {
+    return { request: message, type: "server_request" };
+  }
+  return null;
+}
+function serverNotificationThreadId(notification) {
+  const params = notification.params;
+  if (typeof params?.threadId === "string") {
+    return params.threadId;
+  }
+  const thread = params?.thread;
+  if (typeof thread?.id === "string") {
+    return thread.id;
+  }
+  const turn = params?.turn;
+  if (typeof turn?.threadId === "string") {
+    return turn.threadId;
+  }
+  return null;
+}
+function serverRequestThreadId(request) {
+  const params = request.params;
+  return typeof params?.threadId === "string" ? params.threadId : null;
+}
+function connectionRequestKey(requestId) {
+  return `${requestId.connectionId}:${String(requestId.requestId)}`;
+}
+function isServerRequest(message) {
+  return typeof message.method === "string" && Object.prototype.hasOwnProperty.call(message, "id");
+}
+function isServerNotification(message) {
+  return typeof message.method === "string" && !Object.prototype.hasOwnProperty.call(message, "id");
+}
+
+// src/upstream/codex-rs/app-server/src/request_processors/request_errors.ts
+var CodexAppServerRequestError = class extends Error {
+  constructor(error, status = 400) {
+    super(error.message);
+    this.error = error;
+    this.status = status;
+    this.name = "CodexAppServerRequestError";
+  }
+  error;
+  status;
+};
+function unsupportedMethodError(method, requestId) {
+  return {
+    code: -32601,
+    data: { requestId },
+    message: `Unsupported Codex App Server method: ${method}`
+  };
+}
+function errorToJsonRpcError(error) {
+  if (typeof error === "object" && error !== null && typeof error.code === "number" && typeof error.message === "string") {
+    return error;
+  }
+  return {
+    code: -32e3,
+    message: error instanceof Error ? error.message : "Codex App Server request failed."
+  };
+}
+
+// src/upstream/codex-rs/app-server/src/connection_rpc_gate.ts
+var ConnectionRpcGateClosedError = class extends Error {
+  constructor() {
+    super("Codex App Server connection is closed.");
+    this.name = "ConnectionRpcGateClosedError";
+  }
+};
+var ConnectionRpcGate = class {
+  accepting = true;
+  inFlight = 0;
+  shutdownWaiters = /* @__PURE__ */ new Set();
+  isAccepting() {
+    return this.accepting;
+  }
+  async run(work) {
+    if (!this.accepting) {
+      throw new ConnectionRpcGateClosedError();
+    }
+    this.inFlight += 1;
+    try {
+      return await work();
+    } finally {
+      this.inFlight -= 1;
+      if (!this.accepting && this.inFlight === 0) {
+        for (const resolve of this.shutdownWaiters) {
+          resolve();
+        }
+        this.shutdownWaiters.clear();
+      }
+    }
+  }
+  async shutdown() {
+    this.accepting = false;
+    if (this.inFlight === 0) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.shutdownWaiters.add(resolve);
+    });
+  }
+};
+
+// src/upstream/codex-rs/app-server/src/request_serialization.ts
+var RequestSerializationQueues = class {
+  tails = /* @__PURE__ */ new Map();
+  async enqueue(key, work) {
+    const previous = this.tails.get(key) ?? Promise.resolve();
+    const current = previous.catch(() => void 0).then(() => work());
+    const tail = current.catch(() => void 0).finally(() => {
+      if (this.tails.get(key) === tail) {
+        this.tails.delete(key);
+      }
+    });
+    this.tails.set(
+      key,
+      tail
+    );
+    return current;
+  }
+};
+function requestSerializationQueueKeyFromScope(connectionId, scope) {
+  switch (scope.type) {
+    case "global":
+      return `global:${scope.key}`;
+    case "thread":
+      return `thread:${scope.threadId}`;
+    case "threadPath":
+      return `thread-path:${scope.path}`;
+    case "commandExecProcess":
+      return `connection:${connectionId}:command-exec-process:${scope.processId}`;
+    case "process":
+      return `connection:${connectionId}:process:${scope.processHandle}`;
+    case "fuzzyFileSearchSession":
+      return `fuzzy-file-search-session:${scope.sessionId}`;
+    case "fsWatch":
+      return `connection:${connectionId}:fs-watch:${scope.watchId}`;
+    case "mcpOauth":
+      return `mcp-oauth:${scope.serverName}`;
+  }
+}
+
+// src/upstream/codex-rs/app-server/src/message_processor.ts
+var CodexAppServerConnectionSessionState = class {
+  rpcGate = new ConnectionRpcGate();
+  initializedState = null;
+  constructor(initializedState) {
+    this.initializedState = initializedState ?? null;
+  }
+  initialized() {
+    return this.initializedState !== null;
+  }
+  initialize(state) {
+    if (this.initializedState) {
+      throw invalidRequest("Already initialized");
+    }
+    this.initializedState = state;
+  }
+  experimentalApiEnabled() {
+    return this.initializedState?.experimentalApiEnabled ?? false;
+  }
+  optedOutNotificationMethods() {
+    return this.initializedState?.optedOutNotificationMethods ?? /* @__PURE__ */ new Set();
+  }
+  appServerClientName() {
+    return this.initializedState?.appServerClientName ?? null;
+  }
+  clientVersion() {
+    return this.initializedState?.clientVersion ?? null;
+  }
+};
+var CODEX_APP_SERVER_DEFERRED_RESPONSE = {
+  __codexAppServerDeferredResponse: true
+};
+function codexAppServerDeferredResponse() {
+  return CODEX_APP_SERVER_DEFERRED_RESPONSE;
+}
+var CodexAppServerMessageProcessor = class {
+  connectionId;
+  requestSerializationQueues;
+  session;
+  handlers;
+  initializeResponse;
+  outgoing;
+  constructor(options) {
+    this.connectionId = options.connectionId ?? defaultConnectionId();
+    this.handlers = options.handlers;
+    this.initializeResponse = options.initializeResponse;
+    this.outgoing = options.outgoing;
+    this.requestSerializationQueues = options.requestSerializationQueues ?? new RequestSerializationQueues();
+    this.session = options.session ?? new CodexAppServerConnectionSessionState();
+  }
+  async processClientRequest(request, context) {
+    if (request.method === "initialize") {
+      return this.initialize(request.params, context);
+    }
+    if (!this.session.initialized()) {
+      throw invalidRequest("Not initialized");
+    }
+    const experimentalReason = clientRequestExperimentalReason(request);
+    if (experimentalReason && !this.session.experimentalApiEnabled()) {
+      throw invalidRequest(experimentalRequiredMessage(experimentalReason));
+    }
+    const scope = clientRequestSerializationScope(request);
+    const run = () => this.session.rpcGate.run(
+      () => this.handleInitializedClientRequest(request, context)
+    );
+    try {
+      if (!scope) {
+        return await run();
+      }
+      return await this.requestSerializationQueues.enqueue(
+        requestSerializationQueueKeyFromScope(this.connectionId, scope),
+        run
+      );
+    } catch (error) {
+      if (error instanceof ConnectionRpcGateClosedError) {
+        throw new CodexAppServerRequestError(
+          {
+            code: -32e3,
+            message: error.message
+          },
+          499
+        );
+      }
+      throw error;
+    }
+  }
+  async processConnectionRequest(request, context) {
+    if (!this.outgoing) {
+      const result = await this.processClientRequest(request, context);
+      return { result, type: "response" };
+    }
+    const requestId = this.connectionRequestId(request.id);
+    this.outgoing.registerRequestContext({
+      connectionId: requestId.connectionId,
+      requestId: requestId.requestId
+    });
+    try {
+      const result = await this.processClientRequest(request, context);
+      if (isCodexAppServerDeferredResponse(result)) {
+        return { type: "deferred" };
+      }
+      await this.outgoing.sendResponse(requestId, result);
+      return { result, type: "response" };
+    } catch (error) {
+      const responseError = error instanceof CodexAppServerRequestError ? error.error : {
+        code: -32e3,
+        message: error instanceof Error ? error.message : "Codex App Server request failed."
+      };
+      await this.outgoing.sendError(requestId, responseError);
+      return { error: responseError, type: "error" };
+    }
+  }
+  async shutdown() {
+    await this.session.rpcGate.shutdown();
+  }
+  connectionClosed() {
+    this.outgoing?.connectionClosed(this.connectionId);
+    return this.shutdown();
+  }
+  async initialize(params, context) {
+    validateClientInfo(params.clientInfo);
+    const capabilities = params.capabilities;
+    this.session.initialize({
+      appServerClientName: params.clientInfo.name,
+      clientVersion: params.clientInfo.version,
+      experimentalApiEnabled: capabilities?.experimentalApi ?? false,
+      optedOutNotificationMethods: new Set(
+        capabilities?.optOutNotificationMethods ?? []
+      )
+    });
+    if (this.handlers.initialize) {
+      return this.handlers.initialize(params, context, this.session);
+    }
+    return this.defaultInitializeResponse();
+  }
+  async handleInitializedClientRequest(request, context) {
+    switch (request.method) {
+      case "thread/start":
+        return this.handlers.threadStart(request.params, context);
+      case "thread/resume":
+        return this.handlers.threadResume(request.params, context);
+      case "thread/list":
+        if (this.handlers.threadList) {
+          return this.handlers.threadList(request.params, context);
+        }
+        break;
+      case "thread/read":
+        if (this.handlers.threadRead) {
+          return this.handlers.threadRead(request.params, context);
+        }
+        break;
+      case "thread/name/set":
+        if (this.handlers.threadNameSet) {
+          return this.handlers.threadNameSet(request.params, context);
+        }
+        break;
+      case "thread/archive":
+        if (this.handlers.threadArchive) {
+          return this.handlers.threadArchive(request.params, context);
+        }
+        break;
+      case "thread/unarchive":
+        if (this.handlers.threadUnarchive) {
+          return this.handlers.threadUnarchive(request.params, context);
+        }
+        break;
+      case "thread/metadata/update":
+        if (this.handlers.threadMetadataUpdate) {
+          return this.handlers.threadMetadataUpdate(request.params, context);
+        }
+        break;
+      case "turn/start":
+        return this.handlers.turnStart(request.params, context);
+      case "turn/steer":
+        return this.handlers.turnSteer(request.params, context);
+      case "turn/interrupt":
+        return this.handlers.turnInterrupt(request.params, context);
+      case "thread/compact/start":
+        return this.handlers.threadCompactStart(request.params, context);
+      case "collaborationMode/list":
+        if (this.handlers.collaborationModeList) {
+          return this.handlers.collaborationModeList(request.params, context);
+        }
+        return {
+          data: builtinCollaborationModePresets().map(
+            appServerCollaborationModeMask
+          )
+        };
+      case "config/mcpServer/reload":
+        if (this.handlers.configMcpServerReload) {
+          return this.handlers.configMcpServerReload(request.params, context);
+        }
+        break;
+      case "mcpServerStatus/list":
+        if (this.handlers.mcpServerStatusList) {
+          return this.handlers.mcpServerStatusList(
+            request.params,
+            context,
+            this.requestContext(request.id)
+          );
+        }
+        break;
+      case "mcpServer/resource/read":
+        if (this.handlers.mcpResourceRead) {
+          return this.handlers.mcpResourceRead(
+            request.params,
+            context,
+            this.requestContext(request.id)
+          );
+        }
+        break;
+      case "mcpServer/tool/call":
+        if (this.handlers.mcpServerToolCall) {
+          return this.handlers.mcpServerToolCall(
+            request.params,
+            context,
+            this.requestContext(request.id)
+          );
+        }
+        break;
+      case "mcpServer/oauth/login":
+        if (this.handlers.mcpServerOauthLogin) {
+          return this.handlers.mcpServerOauthLogin(request.params, context);
+        }
+        break;
+    }
+    throw new CodexAppServerRequestError(
+      unsupportedMethodError(request.method, request.id),
+      404
+    );
+  }
+  defaultInitializeResponse() {
+    const response = typeof this.initializeResponse === "function" ? this.initializeResponse() : this.initializeResponse;
+    return response ?? {
+      codexHome: "/",
+      platformFamily: platformFamily(),
+      platformOs: platformOs(),
+      userAgent: "codex-js"
+    };
+  }
+  connectionRequestId(requestId) {
+    return {
+      connectionId: this.connectionId,
+      requestId
+    };
+  }
+  requestContext(requestId) {
+    if (!this.outgoing) {
+      return void 0;
+    }
+    return {
+      connectionId: this.connectionId,
+      outgoing: this.outgoing,
+      requestId: this.connectionRequestId(requestId),
+      session: this.session
+    };
+  }
+};
+function isCodexAppServerDeferredResponse(value) {
+  return typeof value === "object" && value !== null && value.__codexAppServerDeferredResponse === true;
+}
+function validateClientInfo(clientInfo) {
+  if (!clientInfo.name || /[\r\n]/u.test(clientInfo.name)) {
+    throw invalidRequest(
+      `Invalid clientInfo.name: '${clientInfo.name}'. Must be a valid HTTP header value.`
+    );
+  }
+}
+function invalidRequest(message) {
+  return new CodexAppServerRequestError(
+    { code: -32600, message },
+    400
+  );
+}
+function experimentalRequiredMessage(reason) {
+  return `Experimental API capability is required for ${reason}.`;
+}
+function defaultConnectionId() {
+  return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+}
+function platformFamily() {
+  const navigatorPlatform = globalThis.navigator?.platform;
+  if (navigatorPlatform?.toLowerCase().includes("win")) {
+    return "windows";
+  }
+  return "unix";
+}
+function platformOs() {
+  const navigatorPlatform = globalThis.navigator?.platform?.toLowerCase();
+  if (navigatorPlatform?.includes("mac")) {
+    return "macos";
+  }
+  if (navigatorPlatform?.includes("win")) {
+    return "windows";
+  }
+  if (navigatorPlatform?.includes("linux")) {
+    return "linux";
+  }
+  return "unknown";
+}
+function appServerCollaborationModeMask(mask) {
+  return {
+    name: mask.name,
+    mode: mask.mode ?? null,
+    model: mask.model ?? null,
+    reasoning_effort: mask.reasoning_effort === void 0 ? null : mask.reasoning_effort
+  };
+}
+
+// src/upstream/codex-rs/app-server/src/request_processors/common.ts
+function appServerUserInputToCoreUserInput(input) {
+  switch (input.type) {
+    case "text":
+      return {
+        type: "text",
+        text: input.text,
+        text_elements: (input.text_elements ?? []).map((element) => ({
+          byte_range: element.byteRange,
+          placeholder: element.placeholder ?? void 0
+        }))
+      };
+    case "image":
+      return { type: "image", image_url: input.url };
+    case "localImage":
+      return { type: "local_image", path: input.path };
+    case "skill":
+      return { type: "skill", name: input.name, path: input.path };
+    case "mention":
+      return { type: "mention", name: input.name, path: input.path };
+  }
+}
+function threadIdFromStartParams(params) {
+  const maybeThreadId = params.threadId;
+  return asThreadId(typeof maybeThreadId === "string" ? maybeThreadId : defaultId());
+}
+function defaultId() {
+  const crypto = globalThis.crypto;
+  return crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`;
+}
+function valueOrNull(value) {
+  return value === void 0 ? null : value;
+}
+function approvalPolicyString(value) {
+  return typeof value === "string" ? value : null;
+}
+function jsonRpcError(message, code, status) {
+  throw new CodexAppServerRequestError(
+    { code, message },
+    status
+  );
+}
+function steerErrorCode(kind) {
+  switch (kind) {
+    case SteerInputErrorKind.EmptyInput:
+      return -32602;
+    case SteerInputErrorKind.NoActiveTurn:
+      return -32012;
+    case SteerInputErrorKind.ExpectedTurnMismatch:
+      return -32013;
+    case SteerInputErrorKind.ActiveTurnNotSteerable:
+      return -32015;
+  }
+}
+
+// src/upstream/codex-rs/app-server/src/request_processors/mcp_processor.ts
+var MCP_TOOL_THREAD_ID_META_KEY = "threadId";
+var McpRequestProcessor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async mcpServerRefresh(_params, context) {
+    await this.options.reloadMcpServers?.({ context });
+    return {};
+  }
+  async mcpServerStatusList(params, context, request) {
+    if (request) {
+      this.runDeferred(
+        request,
+        context,
+        () => this.mcpServerStatusListResponse(params)
+      );
+      return codexAppServerDeferredResponse();
+    }
+    return this.mcpServerStatusListResponse(params);
+  }
+  async mcpServerStatusListResponse(params) {
+    const detail = params.detail ?? "full";
+    const statuses = await this.manager().list_server_statuses({ detail });
+    const total = statuses.length;
+    const limit = Math.min(Math.max(params.limit ?? total, 1), total);
+    const start = params.cursor ? parseCursor(params.cursor) : 0;
+    if (start > total) {
+      jsonRpcError(
+        `cursor ${start} exceeds total MCP servers ${total}`,
+        -32600,
+        400
+      );
+    }
+    const end = Math.min(start + limit, total);
+    return {
+      data: statuses.slice(start, end).map(
+        (status) => appServerMcpServerStatus(status, detail)
+      ),
+      nextCursor: end < total ? String(end) : null
+    };
+  }
+  async mcpResourceRead(params, context, request) {
+    if (request) {
+      this.runDeferred(
+        request,
+        context,
+        () => this.mcpResourceReadResponse(params)
+      );
+      return codexAppServerDeferredResponse();
+    }
+    return this.mcpResourceReadResponse(params);
+  }
+  async mcpResourceReadResponse(params) {
+    if (params.threadId) {
+      await this.loadThread(params.threadId);
+    }
+    const response = await this.manager().read_resource({
+      thread_id: params.threadId ? asThreadId(params.threadId) : null,
+      server_name: params.server,
+      uri: params.uri
+    });
+    return {
+      contents: response.contents.map(
+        (content) => appServerResourceContent(content, params.uri)
+      )
+    };
+  }
+  async mcpServerToolCall(params, context, request) {
+    if (request) {
+      this.runDeferred(
+        request,
+        context,
+        () => this.mcpServerToolCallResponse(params)
+      );
+      return codexAppServerDeferredResponse();
+    }
+    return this.mcpServerToolCallResponse(params);
+  }
+  async mcpServerToolCallResponse(params) {
+    const threadId = await this.loadThread(params.threadId);
+    const response = await this.manager().call_tool({
+      arguments: params.arguments,
+      meta: with_mcp_tool_call_thread_id_meta(params._meta, threadId),
+      server_name: params.server,
+      thread_id: threadId,
+      tool_name: params.tool
+    });
+    return appServerMcpToolCallResponse(response);
+  }
+  async mcpServerOauthLogin(params, context) {
+    if (!this.options.mcpServerOauthLogin) {
+      jsonRpcError("MCP OAuth login is unavailable.", -32600, 400);
+    }
+    return this.options.mcpServerOauthLogin({ context, params });
+  }
+  manager() {
+    return this.options.mcpConnectionManager ?? EmptyMcpConnectionManager.instance;
+  }
+  runDeferred(request, context, work) {
+    const promise = (async () => {
+      try {
+        await request.outgoing.sendResponse(
+          request.requestId,
+          await work(),
+          context
+        );
+      } catch (error) {
+        await request.outgoing.sendError(
+          request.requestId,
+          jsonRpcErrorFromUnknown(error),
+          context
+        );
+      }
+    })();
+    if (this.options.runInBackground) {
+      this.options.runInBackground(promise, { context });
+      return;
+    }
+  }
+  async loadThread(threadIdString) {
+    let threadId;
+    try {
+      threadId = asThreadId(threadIdString);
+    } catch (error) {
+      jsonRpcError(
+        `invalid thread id: ${error instanceof Error ? error.message : String(error)}`,
+        -32600,
+        400
+      );
+    }
+    try {
+      await this.options.store.readThread({
+        thread_id: threadId,
+        include_archived: false,
+        include_history: false
+      });
+    } catch {
+      jsonRpcError(`thread not found: ${threadId}`, -32600, 400);
+    }
+    return threadId;
+  }
+};
+function parseCursor(cursor) {
+  if (!/^\d+$/u.test(cursor)) {
+    jsonRpcError(`invalid cursor: ${cursor}`, -32600, 400);
+  }
+  const parsed = Number.parseInt(cursor, 10);
+  return parsed;
+}
+function appServerMcpServerStatus(status, detail) {
+  return {
+    authStatus: status.authStatus ?? status.auth_status ?? "unsupported",
+    name: status.name,
+    resources: detail === "toolsAndAuthOnly" ? [] : (status.resources ?? []).map(appServerResource),
+    resourceTemplates: detail === "toolsAndAuthOnly" ? [] : (status.resource_templates ?? []).map(appServerResourceTemplate),
+    tools: Object.fromEntries(
+      (status.tools ?? []).map((tool) => [tool.name, appServerTool(tool)])
+    )
+  };
+}
+function appServerTool(tool) {
+  return omitUndefined({
+    name: tool.name,
+    title: tool.title ?? void 0,
+    description: tool.description ?? void 0,
+    inputSchema: tool.input_schema ?? { type: "object" }
+  });
+}
+function appServerResource(resource) {
+  return omitUndefined({
+    uri: resource.uri,
+    name: resource.name ?? resource.uri,
+    description: resource.description ?? void 0,
+    mimeType: resource.mime_type ?? void 0
+  });
+}
+function appServerResourceTemplate(template) {
+  return omitUndefined({
+    uriTemplate: template.uri_template,
+    name: template.name ?? template.uri_template,
+    title: void 0,
+    description: template.description ?? void 0,
+    mimeType: template.mime_type ?? void 0
+  });
+}
+function appServerResourceContent(content, fallbackUri) {
+  if (!isRecord2(content)) {
+    return { uri: fallbackUri, text: String(content) };
+  }
+  const uri = typeof content.uri === "string" ? content.uri : fallbackUri;
+  const mimeType = typeof content.mimeType === "string" ? content.mimeType : typeof content.mime_type === "string" ? content.mime_type : void 0;
+  if (typeof content.blob === "string") {
+    return omitUndefined({
+      uri,
+      mimeType,
+      blob: content.blob,
+      _meta: content._meta
+    });
+  }
+  return omitUndefined({
+    uri,
+    mimeType,
+    text: typeof content.text === "string" ? content.text : JSON.stringify(content),
+    _meta: content._meta
+  });
+}
+function appServerMcpToolCallResponse(response) {
+  const output = response.output;
+  const record = isRecord2(output) ? output : {};
+  const structuredContent = record.structuredContent ?? record.structured_content ?? void 0;
+  const isError2 = record.isError ?? record.is_error ?? void 0;
+  return omitUndefined({
+    content: Array.isArray(record.content) ? record.content : [],
+    structuredContent,
+    isError: typeof isError2 === "boolean" ? isError2 : void 0,
+    _meta: record._meta
+  });
+}
+function with_mcp_tool_call_thread_id_meta(meta, threadId) {
+  if (meta === void 0) {
+    return { [MCP_TOOL_THREAD_ID_META_KEY]: threadId };
+  }
+  if (isRecord2(meta)) {
+    return {
+      ...meta,
+      [MCP_TOOL_THREAD_ID_META_KEY]: threadId
+    };
+  }
+  return meta;
+}
+function jsonRpcErrorFromUnknown(error) {
+  if (error instanceof CodexAppServerRequestError) {
+    return error.error;
+  }
+  return {
+    code: -32e3,
+    message: error instanceof Error ? error.message : "Codex App Server request failed."
+  };
+}
+function omitUndefined(record) {
+  return Object.fromEntries(
+    Object.entries(record).filter(([, value]) => value !== void 0)
+  );
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/upstream/codex-rs/app-server/src/request_processors/token_usage_replay.ts
+function latest_token_usage_turn_id_from_rollout_items(rolloutItems, turns) {
+  const builder = new ThreadHistoryBuilder();
+  let tokenUsageTurnOwner = null;
+  for (const item of rolloutItems) {
+    if (item.type === "event_msg" && item.payload.type === "token_count") {
+      const turn = builder.active_turn_snapshot();
+      tokenUsageTurnOwner = turn ? {
+        id: appServerTurnFromCoreTurn(turn).id,
+        position: builder.active_turn_position()
+      } : null;
+    }
+    builder.handle_rollout_item(item);
+  }
+  if (!tokenUsageTurnOwner) {
+    return null;
+  }
+  if (turns.some((turn) => turn.id === tokenUsageTurnOwner.id)) {
+    return tokenUsageTurnOwner.id;
+  }
+  return tokenUsageTurnOwner.position === null ? null : turns[tokenUsageTurnOwner.position]?.id ?? null;
+}
+function latest_token_usage_turn_id(thread) {
+  return [...thread.turns].reverse().find((turn) => turn.status === "completed" || turn.status === "failed")?.id ?? thread.turns.at(-1)?.id ?? "";
+}
+function last_token_info_from_rollout_items(rolloutItems) {
+  for (let index = rolloutItems.length - 1; index >= 0; index -= 1) {
+    const item = rolloutItems[index];
+    if (item?.type === "event_msg" && item.payload.type === "token_count" && item.payload.info) {
+      return item.payload.info;
+    }
+  }
+  return null;
+}
+function thread_token_usage_updated_notification_from_info(input) {
+  const params = {
+    threadId: String(input.threadId),
+    turnId: input.tokenUsageTurnId ?? latest_token_usage_turn_id(input.thread),
+    tokenUsage: threadTokenUsageFromTokenUsageInfo(input.tokenUsageInfo)
+  };
+  return {
+    method: "thread/tokenUsage/updated",
+    params
+  };
+}
+function thread_token_usage_updated_notification_from_rollout_items(input) {
+  const tokenUsageInfo = last_token_info_from_rollout_items(input.rolloutItems);
+  if (!tokenUsageInfo) {
+    return null;
+  }
+  return thread_token_usage_updated_notification_from_info({
+    thread: input.thread,
+    threadId: input.threadId,
+    tokenUsageInfo,
+    tokenUsageTurnId: latest_token_usage_turn_id_from_rollout_items(
+      input.rolloutItems,
+      input.thread.turns
+    )
+  });
+}
+
+// src/upstream/codex-rs/app-server/src/request_processors/thread_processor.ts
+var THREAD_LIST_DEFAULT_LIMIT = 25;
+var THREAD_LIST_MAX_LIMIT = 100;
+var ThreadRequestProcessor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async threadStart(params, context) {
+    const liveThread = await this.ensureLiveThread(params, context);
+    const response = await this.readThreadResponse(liveThread.threadId);
+    await this.options.emit(
+      liveThread.threadId,
+      {
+        type: "server_notification",
+        notification: {
+          method: "thread/started",
+          params: { thread: response.thread }
+        }
+      },
+      context
+    );
+    return response;
+  }
+  async threadResume(params, context) {
+    const threadId = asThreadId(params.threadId);
+    const { history, response } = await this.readThreadResponseWithHistory(threadId);
+    const replay = thread_token_usage_updated_notification_from_rollout_items({
+      rolloutItems: history.items,
+      thread: response.thread,
+      threadId
+    });
+    if (replay) {
+      await this.options.emit(threadId, {
+        notification: replay,
+        type: "server_notification"
+      }, context);
+    }
+    return response;
+  }
+  async threadCompactStart(params, context) {
+    const threadId = asThreadId(params.threadId);
+    let runtimeSession = this.options.sessions.get(threadId);
+    if (runtimeSession?.session.activeTurn) {
+      throw jsonRpcError("Wait for the active turn to finish before compacting.", -32014, 409);
+    }
+    const submission = {
+      id: `compact-${defaultId()}`,
+      op: { type: "compact" }
+    };
+    if (!runtimeSession) {
+      const session = await this.options.createSession(threadId, params, context, submission);
+      runtimeSession = {
+        abortController: null,
+        runPromise: null,
+        session
+      };
+      this.options.sessions.set(threadId, runtimeSession);
+    }
+    await this.options.taskRunner.startCompactTask({
+      context,
+      params,
+      runtimeSession,
+      submission,
+      threadId
+    });
+    return {};
+  }
+  async threadList(params) {
+    const pageSize = Math.max(
+      1,
+      Math.min(params.limit ?? THREAD_LIST_DEFAULT_LIMIT, THREAD_LIST_MAX_LIMIT)
+    );
+    const page = await this.options.store.listThreads({
+      allowed_sources: params.sourceKinds?.length ? params.sourceKinds : [],
+      archived: params.archived ?? false,
+      cursor: params.cursor ?? null,
+      cwd_filters: cwdFilters(params.cwd),
+      model_providers: params.modelProviders ?? null,
+      page_size: pageSize,
+      search_term: params.searchTerm ?? null,
+      sort_direction: params.sortDirection === "asc" ? SortDirection.Asc : SortDirection.Desc,
+      sort_key: params.sortKey === "updated_at" ? ThreadSortKey.UpdatedAt : ThreadSortKey.CreatedAt,
+      use_state_db_only: params.useStateDbOnly ?? false
+    });
+    return {
+      backwardsCursor: null,
+      data: page.items.map(
+        (thread) => threadHistoryToAppServerThread({
+          history: { items: [], thread_id: thread.thread_id },
+          thread
+        })
+      ),
+      nextCursor: page.next_cursor ?? null
+    };
+  }
+  async threadRead(params) {
+    const threadId = asThreadId(params.threadId);
+    const storedThread = await this.options.store.readThread({
+      thread_id: threadId,
+      include_archived: true,
+      include_history: params.includeTurns
+    });
+    const history = params.includeTurns ? storedThread.history ?? await this.options.store.loadHistory({
+      thread_id: threadId,
+      include_archived: true
+    }) : { items: [], thread_id: threadId };
+    return {
+      thread: threadHistoryToAppServerThread({
+        history,
+        thread: storedThread
+      })
+    };
+  }
+  async threadNameSet(params, context) {
+    const threadId = asThreadId(params.threadId);
+    const name = normalizeThreadName(params.name);
+    if (!name) {
+      jsonRpcError("thread name must not be empty", -32600, 400);
+    }
+    await this.options.store.updateThreadMetadata({
+      thread_id: threadId,
+      include_archived: false,
+      patch: { name }
+    });
+    await this.options.emit(
+      threadId,
+      {
+        type: "server_notification",
+        notification: {
+          method: "thread/name/updated",
+          params: { threadId, threadName: name }
+        }
+      },
+      context
+    );
+    return {};
+  }
+  async threadArchive(params, context) {
+    const threadId = asThreadId(params.threadId);
+    await this.options.store.archiveThread({ thread_id: threadId });
+    await this.options.emit(
+      threadId,
+      {
+        type: "server_notification",
+        notification: {
+          method: "thread/archived",
+          params: { threadId }
+        }
+      },
+      context
+    );
+    return {};
+  }
+  async threadUnarchive(params, context) {
+    const threadId = asThreadId(params.threadId);
+    const storedThread = await this.options.store.unarchiveThread({
+      thread_id: threadId
+    });
+    await this.options.emit(
+      threadId,
+      {
+        type: "server_notification",
+        notification: {
+          method: "thread/unarchived",
+          params: { threadId }
+        }
+      },
+      context
+    );
+    return {
+      thread: threadHistoryToAppServerThread({
+        history: { items: [], thread_id: threadId },
+        thread: storedThread
+      })
+    };
+  }
+  async threadMetadataUpdate(params) {
+    const threadId = asThreadId(params.threadId);
+    if (!params.gitInfo || params.gitInfo.sha === void 0 && params.gitInfo.branch === void 0 && params.gitInfo.originUrl === void 0) {
+      jsonRpcError("gitInfo must include at least one field", -32600, 400);
+    }
+    const storedThread = await this.options.store.updateThreadMetadata({
+      thread_id: threadId,
+      include_archived: true,
+      patch: {
+        git_info: {
+          branch: normalizeOptionalGitField(params.gitInfo.branch, "gitInfo.branch"),
+          origin_url: normalizeOptionalGitField(
+            params.gitInfo.originUrl,
+            "gitInfo.originUrl"
+          ),
+          sha: normalizeOptionalGitField(params.gitInfo.sha, "gitInfo.sha")
+        }
+      }
+    });
+    return {
+      thread: threadHistoryToAppServerThread({
+        history: { items: [], thread_id: threadId },
+        thread: storedThread
+      })
+    };
+  }
+  async readThreadResponse(threadId) {
+    return (await this.readThreadResponseWithHistory(threadId)).response;
+  }
+  async readThreadResponseWithHistory(threadId) {
+    const thread = await this.options.store.readThread({
+      thread_id: threadId,
+      include_archived: false,
+      include_history: false
+    });
+    const history = await this.options.store.loadHistory({
+      thread_id: threadId,
+      include_archived: false
+    });
+    return {
+      history,
+      response: buildThreadResumeResponseFromHistory({ history, thread }),
+      thread
+    };
+  }
+  async createThreadParams(params, context) {
+    const threadId = threadIdFromStartParams(params);
+    if (this.options.buildCreateThreadParams) {
+      return this.options.buildCreateThreadParams({ context, params, threadId });
+    }
+    const dynamicTools = await this.options.resolveDynamicTools?.({ context, params, threadId }) ?? [];
+    return {
+      base_instructions: {
+        text: params.baseInstructions ?? BaseInstructions.default().text
+      },
+      dynamic_tools: dynamicTools,
+      event_persistence_mode: ThreadEventPersistenceMode.Limited,
+      metadata: {
+        cwd: params.cwd ?? "/",
+        memory_mode: ThreadMemoryMode.Disabled,
+        model: params.model ?? "gpt-5.5",
+        model_provider: params.modelProvider ?? "openai"
+      },
+      source: "appServer",
+      thread_id: threadId,
+      thread_source: typeof params.threadSource === "string" ? params.threadSource : null
+    };
+  }
+  async ensureLiveThread(params, context) {
+    const createParams = await this.createThreadParams(params, context);
+    validateDynamicToolSpecs(createParams.dynamic_tools);
+    try {
+      await this.options.store.readThread({
+        thread_id: createParams.thread_id,
+        include_archived: false,
+        include_history: false
+      });
+      return LiveThread.resume(this.options.store, {
+        thread_id: createParams.thread_id,
+        include_archived: false,
+        metadata: createParams.metadata,
+        event_persistence_mode: createParams.event_persistence_mode
+      });
+    } catch {
+      return LiveThread.create(this.options.store, createParams);
+    }
+  }
+};
+function validateDynamicToolSpecs(tools) {
+  for (const tool of tools) {
+    if (tool.defer_loading && !tool.namespace) {
+      jsonRpcError(
+        `Dynamic tool ${tool.name} uses defer_loading and must include a namespace.`,
+        -32600,
+        400
+      );
+    }
+    const invalidName = invalidResponsesApiToolName(tool.name) ? tool.name : tool.namespace && invalidResponsesApiToolName(tool.namespace) ? tool.namespace : null;
+    if (invalidName) {
+      jsonRpcError(
+        `Dynamic tool ${invalidName} is not supported by the Responses API. Tool names and namespaces may only contain letters, numbers, underscores, and hyphens.`,
+        -32600,
+        400
+      );
+    }
+  }
+}
+function invalidResponsesApiToolName(value) {
+  return !/^[A-Za-z0-9_-]+$/.test(value);
+}
+function cwdFilters(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return null;
+}
+function normalizeThreadName(value) {
+  const name = value.trim().replace(/\s+/gu, " ");
+  return name ? name : null;
+}
+function normalizeOptionalGitField(value, field) {
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    jsonRpcError(`${field} must not be empty`, -32600, 400);
+  }
+  return trimmed;
+}
+
+// src/upstream/codex-rs/app-server/src/request_processors/turn_processor.ts
+var TurnRequestProcessor = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async turnStart(params, context) {
+    const threadId = asThreadId(params.threadId);
+    const input = params.input.map(appServerUserInputToCoreUserInput);
+    const collaborationModeInput = params.collaborationMode ?? params.collaboration_mode;
+    const collaborationMode = collaborationModeInput ? normalizeCollaborationMode({
+      collaborationMode: collaborationModeInput,
+      model: valueOrNull(params.model) ?? "gpt-5.5",
+      reasoningEffort: valueOrNull(params.effort) ?? null
+    }) : void 0;
+    const submission = {
+      id: params.clientMessageId ?? defaultId(),
+      op: {
+        type: "user_input_with_turn_context",
+        items: input,
+        cwd: valueOrNull(params.cwd) ?? void 0,
+        approval_policy: approvalPolicyString(params.approvalPolicy) ?? void 0,
+        approvals_reviewer: valueOrNull(params.approvalsReviewer) ?? void 0,
+        sandbox_policy: valueOrNull(params.sandboxPolicy) ?? void 0,
+        model: valueOrNull(params.model) ?? void 0,
+        effort: valueOrNull(params.effort) ?? void 0,
+        summary: valueOrNull(params.summary) ?? void 0,
+        service_tier: valueOrNull(params.serviceTier) ?? void 0,
+        collaboration_mode: collaborationMode,
+        personality: valueOrNull(params.personality) ?? void 0,
+        final_output_json_schema: valueOrNull(params.outputSchema) ?? void 0
+      }
+    };
+    const runtimeSession = await this.sessionForTurn(threadId, params, submission, context);
+    if (runtimeSession.session.activeTurn) {
+      throw jsonRpcError("A Codex turn is already active for this thread.", -32011, 409);
+    }
+    const turn = await this.options.taskRunner.startRegularTask({
+      context,
+      items: input,
+      params,
+      runtimeSession,
+      submission,
+      threadId
+    });
+    return {
+      turn: {
+        id: turn.sub_id,
+        items: [],
+        itemsView: "notLoaded",
+        status: "inProgress",
+        error: null,
+        startedAt: Math.floor(Date.now() / 1e3),
+        completedAt: null,
+        durationMs: null
+      }
+    };
+  }
+  async turnSteer(params, context) {
+    const threadId = asThreadId(params.threadId);
+    const runtimeSession = this.options.sessions.get(threadId);
+    if (!runtimeSession) {
+      throw jsonRpcError("No active Codex turn is available for steering.", -32012, 409);
+    }
+    try {
+      const turnId = await runtimeSession.session.steer_input(
+        params.input.map(appServerUserInputToCoreUserInput),
+        params.expectedTurnId
+      );
+      return { turnId };
+    } catch (error) {
+      if (error instanceof SteerInputError) {
+        throw jsonRpcError(error.message, steerErrorCode(error.kind), 409);
+      }
+      this.options.onRuntimeError?.(error, { context, threadId });
+      throw error;
+    }
+  }
+  async turnInterrupt(params) {
+    const threadId = asThreadId(params.threadId);
+    const runtimeSession = this.options.sessions.get(threadId);
+    if (!runtimeSession?.session.activeTurn) {
+      return {};
+    }
+    const activeTask = runtimeSession.session.activeTurn.firstTask();
+    if (activeTask && activeTask.sub_id !== params.turnId) {
+      throw jsonRpcError(
+        `Expected active turn ${params.turnId}, but current active turn is ${activeTask.sub_id}.`,
+        -32013,
+        409
+      );
+    }
+    runtimeSession.abortController?.abort();
+    await runtimeSession.session.abortActiveTurn("interrupted");
+    return {};
+  }
+  async sessionForTurn(threadId, params, submission, context) {
+    const existing = this.options.sessions.get(threadId);
+    if (existing) {
+      return existing;
+    }
+    const session = await this.options.createSession(threadId, params, context, submission);
+    const runtimeSession = {
+      abortController: null,
+      runPromise: null,
+      session
+    };
+    this.options.sessions.set(threadId, runtimeSession);
+    return runtimeSession;
+  }
+};
+
+// src/upstream/codex-rs/app-server/src/dynamic_tools.ts
+function coreDynamicToolResponseFromAppServerResponse(value) {
+  const response = decodeDynamicToolCallResponse(value);
+  return {
+    content_items: response.contentItems.map(coreDynamicToolCallOutputContentItem),
+    success: response.success
+  };
+}
+function decodeDynamicToolCallResponse(value) {
+  if (!isDynamicToolCallResponse(value)) {
+    return fallbackDynamicToolCallResponse("dynamic tool response was invalid");
+  }
+  return value;
+}
+function fallbackDynamicToolCallResponse(message) {
+  return {
+    contentItems: [{ text: message, type: "inputText" }],
+    success: false
+  };
+}
+function coreDynamicToolCallOutputContentItem(item) {
+  switch (item.type) {
+    case "inputText":
+      return { text: item.text, type: "inputText" };
+    case "inputImage":
+      return { imageUrl: item.imageUrl, type: "inputImage" };
+  }
+}
+function isDynamicToolCallResponse(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.success === "boolean" && Array.isArray(candidate.contentItems) && candidate.contentItems.every(isDynamicToolCallOutputContentItem);
+}
+function isDynamicToolCallOutputContentItem(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const item = value;
+  if (item.type === "inputText") {
+    return typeof item.text === "string";
+  }
+  if (item.type === "inputImage") {
+    return typeof item.imageUrl === "string";
+  }
+  return false;
+}
+
+// src/upstream/codex-rs/app-server/src/server_request_response.ts
+function submissionFromServerRequestResult(input) {
+  const target = input.target ?? targetFromServerRequest(input.request);
+  const request = input.request;
+  if (isSubmissionOp(input.result)) {
+    throw unsupportedServerRequestResponse(request);
+  }
+  if (target?.type === "request_permissions") {
+    return {
+      id: `server-request-response-${String(input.requestId)}`,
+      op: {
+        id: target.callId,
+        response: corePermissionsResponse(
+          input.result
+        ),
+        type: "request_permissions_response"
+      }
+    };
+  }
+  if (target?.type === "dynamic_tool") {
+    return {
+      id: `server-request-response-${String(input.requestId)}`,
+      op: {
+        id: target.callId,
+        response: coreDynamicToolResponse(input.result),
+        type: "dynamic_tool_response"
+      }
+    };
+  }
+  if (target?.type === "mcp_elicitation") {
+    return {
+      id: `server-request-response-${String(input.requestId)}`,
+      op: {
+        id: target.requestId,
+        response: coreMcpElicitationResponse(
+          input.result
+        ),
+        server_name: target.serverName,
+        type: "mcp_server_elicitation_response"
+      }
+    };
+  }
+  if (target?.type === "user_input") {
+    return {
+      id: `server-request-response-${String(input.requestId)}`,
+      op: {
+        id: target.responseId,
+        response: coreToolRequestUserInputResponse(
+          input.result
+        ),
+        type: "user_input_answer"
+      }
+    };
+  }
+  throw unsupportedServerRequestResponse(request);
+}
+function coreDynamicToolResponse(response) {
+  return coreDynamicToolResponseFromAppServerResponse(response);
+}
+function corePermissionsResponse(response) {
+  return {
+    permissions: response.permissions,
+    scope: response.scope,
+    strict_auto_review: response.strictAutoReview
+  };
+}
+function coreMcpElicitationResponse(response) {
+  return {
+    action: response.action,
+    content: response.content ?? void 0,
+    meta: response._meta ?? void 0
+  };
+}
+function submissionFromServerRequestError(input) {
+  const target = input.target ?? targetFromServerRequest(input.request);
+  const requestId = String(input.requestId);
+  if (target?.type === "dynamic_tool") {
+    return {
+      id: `server-request-rejection-${requestId}`,
+      op: {
+        id: target.callId,
+        response: {
+          content_items: [
+            {
+              text: input.error.message,
+              type: "inputText"
+            }
+          ],
+          success: false
+        },
+        type: "dynamic_tool_response"
+      }
+    };
+  }
+  if (target?.type === "request_permissions") {
+    return {
+      id: `server-request-rejection-${requestId}`,
+      op: {
+        id: target.callId,
+        response: {
+          permissions: {}
+        },
+        type: "request_permissions_response"
+      }
+    };
+  }
+  if (target?.type === "user_input") {
+    return {
+      id: `server-request-rejection-${requestId}`,
+      op: {
+        id: target.responseId,
+        response: { answers: {} },
+        type: "user_input_answer"
+      }
+    };
+  }
+  if (target?.type === "mcp_elicitation") {
+    return {
+      id: `server-request-rejection-${requestId}`,
+      op: {
+        id: target.requestId,
+        response: {
+          action: "cancel",
+          content: void 0,
+          meta: void 0
+        },
+        server_name: target.serverName,
+        type: "mcp_server_elicitation_response"
+      }
+    };
+  }
+  throw unsupportedServerRequestResponse(input.request);
+}
+function coreToolRequestUserInputResponse(response) {
+  const answers = {};
+  for (const [key, value] of Object.entries(response.answers)) {
+    if (value) {
+      answers[key] = value;
+    }
+  }
+  return { answers };
+}
+function isServerRequestResponseSubmission(submission) {
+  return submission.op.type === "dynamic_tool_response" || submission.op.type === "mcp_server_elicitation_response" || submission.op.type === "request_permissions_response" || submission.op.type === "user_input_answer";
+}
+function isSubmissionOp(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string" && isServerRequestResponseSubmission({ op: value });
+}
+function targetFromServerRequest(request) {
+  if (!request) {
+    return null;
+  }
+  switch (request.method) {
+    case "item/tool/requestUserInput":
+      return {
+        type: "user_input",
+        responseId: request.params.turnId
+      };
+    case "item/permissions/requestApproval":
+      return {
+        type: "request_permissions",
+        callId: request.params.itemId
+      };
+    case "item/tool/call":
+      return { type: "dynamic_tool", callId: request.params.callId };
+    case "mcpServer/elicitation/request":
+      return "elicitationId" in request.params ? {
+        type: "mcp_elicitation",
+        serverName: request.params.serverName,
+        requestId: request.params.elicitationId
+      } : null;
+    default:
+      return null;
+  }
+}
+function unsupportedServerRequestResponse(request) {
+  throw new Error(
+    `Unsupported Codex server-request response: ${request?.method ?? "unknown"}`
+  );
+}
+
+// src/upstream/codex-rs/app-server/src/session_factory.ts
+var CodexSessionFactory = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  createSession = async (input) => {
+    const eventSink = (event) => this.options.emitCoreEvent(input.threadId, event, input.context);
+    if (this.options.createSession) {
+      return this.options.createSession({ ...input, eventSink });
+    }
+    const thread = await this.options.store.readThread({
+      thread_id: input.threadId,
+      include_archived: false,
+      include_history: false
+    });
+    const history = await this.options.store.loadHistory({
+      thread_id: input.threadId,
+      include_archived: false
+    });
+    const overrides = await this.options.buildSessionConfiguration?.({
+      context: input.context,
+      params: input.params,
+      thread
+    });
+    const configuration = defaultSessionConfiguration({
+      approval_policy: "approvalPolicy" in input.params ? approvalPolicyString(input.params.approvalPolicy) ?? "never" : "never",
+      approvals_reviewer: "approvalsReviewer" in input.params ? valueOrNull(input.params.approvalsReviewer) ?? "user" : "user",
+      base_instructions: { text: "" },
+      cwd: "cwd" in input.params ? valueOrNull(input.params.cwd) ?? thread.cwd : thread.cwd,
+      developer_instructions: "developerInstructions" in input.params ? input.params.developerInstructions ?? null : null,
+      model: "model" in input.params ? valueOrNull(input.params.model) ?? thread.model ?? "gpt-5.5" : thread.model ?? "gpt-5.5",
+      provider: "modelProvider" in input.params ? valueOrNull(input.params.modelProvider) ?? thread.model_provider : thread.model_provider,
+      reasoning_effort: "effort" in input.params ? input.params.effort ?? null : null,
+      service_tier: "serviceTier" in input.params ? valueOrNull(input.params.serviceTier) ?? null : null,
+      session_source: "appServer",
+      ...overrides ?? {}
+    });
+    if (!configuration.base_instructions.text) {
+      configuration.base_instructions = {
+        text: "baseInstructions" in input.params && input.params.baseInstructions ? input.params.baseInstructions : BaseInstructions.default().text
+      };
+    }
+    return new Session({
+      threadId: input.threadId,
+      configuration,
+      liveThread: await LiveThread.resume(this.options.store, {
+        thread_id: input.threadId,
+        include_archived: false,
+        metadata: {
+          cwd: thread.cwd,
+          memory_mode: ThreadMemoryMode.Disabled,
+          model_provider: thread.model_provider
+        },
+        event_persistence_mode: ThreadEventPersistenceMode.Limited
+      }),
+      initialHistory: history.items,
+      rolloutPath: thread.rollout_path ?? null,
+      forkedFromId: thread.forked_from_id ?? null,
+      threadName: thread.name ?? null,
+      threadSource: thread.thread_source ?? null,
+      eventSink,
+      mcpConnectionManager: this.options.mcpConnectionManager
+    });
+  };
+};
+
+// src/upstream/codex-rs/app-server/src/session_task_runner.ts
+var CodexSessionTaskRunner = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  modelClients = /* @__PURE__ */ new Map();
+  async startRegularTask(input) {
+    const turn = await input.runtimeSession.session.startTurn(input.submission);
+    const history = await this.options.store.loadHistory({
+      thread_id: input.threadId,
+      include_archived: false
+    });
+    const abortController = new AbortController();
+    const modelClient = await this.modelClient({
+      context: input.context,
+      session: input.runtimeSession.session,
+      threadId: input.threadId
+    });
+    const task = RegularTask.new({
+      history: history.items,
+      submission: input.submission,
+      run_turn: async (taskInput) => {
+        const result = await runTurn({
+          history: taskInput.history,
+          modelClient,
+          session: taskInput.session,
+          signal: taskInput.signal,
+          submission: taskInput.submission,
+          turn: taskInput.turn
+        });
+        return {
+          last_agent_message: result.lastAgentMessage,
+          steps: result.steps
+        };
+      }
+    });
+    this.spawnTask({
+      abortController,
+      context: input.context,
+      input: input.items,
+      runtimeSession: input.runtimeSession,
+      task,
+      threadId: input.threadId,
+      turn
+    });
+    return turn;
+  }
+  async startCompactTask(input) {
+    const history = await this.options.store.loadHistory({
+      thread_id: input.threadId,
+      include_archived: false
+    });
+    const abortController = new AbortController();
+    const turn = await input.runtimeSession.session.startCompactTurn(input.submission);
+    const modelClient = await this.modelClient({
+      context: input.context,
+      session: input.runtimeSession.session,
+      threadId: input.threadId
+    });
+    const task = new CompactTask({
+      history: history.items,
+      submission: input.submission,
+      run_compact_task: async (taskInput) => {
+        const result = await run_compact_task({
+          modelClient,
+          session: taskInput.session,
+          history: taskInput.history,
+          submission: taskInput.submission,
+          turn: taskInput.turn,
+          signal: taskInput.signal,
+          completeTurn: false
+        });
+        return {
+          last_agent_message: null,
+          steps: 1,
+          message: result.summary
+        };
+      }
+    });
+    this.spawnTask({
+      abortController,
+      context: input.context,
+      input: [],
+      runtimeSession: input.runtimeSession,
+      task,
+      threadId: input.threadId,
+      turn
+    });
+    return turn;
+  }
+  spawnTask(input) {
+    input.runtimeSession.abortController = input.abortController;
+    input.runtimeSession.runPromise = input.runtimeSession.session.spawn_task({
+      abortController: input.abortController,
+      input: input.input,
+      task: input.task,
+      turnContext: input.turn
+    }).catch((error) => {
+      this.options.onRuntimeError?.(error, {
+        context: input.context,
+        threadId: input.threadId
+      });
+    }).finally(() => {
+      input.runtimeSession.abortController = null;
+      input.runtimeSession.runPromise = null;
+    });
+    this.options.runInBackground?.(input.runtimeSession.runPromise, {
+      context: input.context,
+      threadId: input.threadId
+    });
+  }
+  async modelClient(input) {
+    const cacheKey = this.options.modelClientCacheKey?.(input) ?? String(input.threadId);
+    const existing = this.modelClients.get(cacheKey);
+    if (existing) {
+      return existing;
+    }
+    const created = await this.options.createModelClient(input);
+    this.modelClients.set(cacheKey, created);
+    return created;
+  }
+};
+
+// src/upstream/codex-rs/app-server/src/thread_state.ts
+var ThreadState = class {
+  pendingInterrupts = [];
+  turnSummary = { lastError: null, startedAt: null };
+  lastTerminalTurnId = null;
+  experimentalRawEvents = false;
+  listenerGeneration = 0;
+  currentTurnHistory = new ThreadHistoryBuilder();
+  listenerActive = false;
+  setListener() {
+    this.listenerGeneration = this.listenerGeneration + 1 >>> 0;
+    this.listenerActive = true;
+    return this.listenerGeneration;
+  }
+  clearListener() {
+    this.listenerActive = false;
+    this.currentTurnHistory.reset();
+  }
+  hasListener() {
+    return this.listenerActive;
+  }
+  setExperimentalRawEvents(enabled) {
+    this.experimentalRawEvents = enabled;
+  }
+  activeTurnSnapshot() {
+    const turn = this.currentTurnHistory.active_turn_snapshot();
+    return turn ? appServerTurnFromCoreTurn(turn) : null;
+  }
+  trackCurrentTurnEvent(eventTurnId, event) {
+    if (event.type === "turn_started") {
+      this.turnSummary.startedAt = event.started_at ?? null;
+    }
+    if (event.type === "error") {
+      this.turnSummary.lastError = { message: event.message };
+    }
+    this.currentTurnHistory.handle_event(event, eventTurnId);
+    if (event.type === "turn_complete" || event.type === "turn_aborted") {
+      this.lastTerminalTurnId = eventTurnId;
+      const terminalTurn = this.currentTurnHistory.finish().find((turn) => turn.id === eventTurnId) ?? null;
+      this.currentTurnHistory.reset();
+      return {
+        activeTurn: null,
+        terminalTurn: terminalTurn ? appServerTurnFromCoreTurn(terminalTurn) : null
+      };
+    }
+    return {
+      activeTurn: this.activeTurnSnapshot(),
+      terminalTurn: null
+    };
+  }
+};
+var ThreadStateManager = class {
+  liveConnections = /* @__PURE__ */ new Set();
+  threads = /* @__PURE__ */ new Map();
+  threadIdsByConnection = /* @__PURE__ */ new Map();
+  connectionInitialized(connectionId) {
+    this.liveConnections.add(connectionId);
+  }
+  threadState(threadId) {
+    const entry = this.threadEntry(threadId);
+    return entry.state;
+  }
+  removeThreadState(threadId) {
+    const entry = this.threads.get(threadId);
+    entry?.state.clearListener();
+    this.threads.delete(threadId);
+    for (const [connectionId, threadIds] of this.threadIdsByConnection) {
+      threadIds.delete(threadId);
+      if (threadIds.size === 0) {
+        this.threadIdsByConnection.delete(connectionId);
+      }
+    }
+  }
+  clearAllListeners() {
+    for (const entry of this.threads.values()) {
+      entry.state.clearListener();
+    }
+  }
+  subscribedConnectionIds(threadId) {
+    return Array.from(this.threads.get(threadId)?.connectionIds ?? []);
+  }
+  tryEnsureConnectionSubscribed(threadId, connectionId, experimentalRawEvents = false) {
+    if (!this.liveConnections.has(connectionId)) {
+      return null;
+    }
+    const threadIds = this.threadIdsByConnection.get(connectionId);
+    if (threadIds) {
+      threadIds.add(threadId);
+    } else {
+      this.threadIdsByConnection.set(connectionId, /* @__PURE__ */ new Set([threadId]));
+    }
+    const entry = this.threadEntry(threadId);
+    entry.connectionIds.add(connectionId);
+    if (experimentalRawEvents) {
+      entry.state.setExperimentalRawEvents(true);
+    }
+    return entry.state;
+  }
+  unsubscribeConnectionFromThread(threadId, connectionId) {
+    const entry = this.threads.get(threadId);
+    const threadIds = this.threadIdsByConnection.get(connectionId);
+    if (!entry || !threadIds?.has(threadId)) {
+      return false;
+    }
+    entry.connectionIds.delete(connectionId);
+    threadIds.delete(threadId);
+    if (threadIds.size === 0) {
+      this.threadIdsByConnection.delete(connectionId);
+    }
+    return true;
+  }
+  removeConnection(connectionId) {
+    this.liveConnections.delete(connectionId);
+    const threadIds = Array.from(this.threadIdsByConnection.get(connectionId) ?? []);
+    this.threadIdsByConnection.delete(connectionId);
+    const emptyThreadIds = [];
+    for (const threadId of threadIds) {
+      const entry = this.threads.get(threadId);
+      entry?.connectionIds.delete(connectionId);
+      if (entry && entry.connectionIds.size === 0) {
+        emptyThreadIds.push(threadId);
+      }
+    }
+    return emptyThreadIds;
+  }
+  threadEntry(threadId) {
+    const existing = this.threads.get(threadId);
+    if (existing) {
+      return existing;
+    }
+    const entry = {
+      connectionIds: /* @__PURE__ */ new Set(),
+      state: new ThreadState()
+    };
+    this.threads.set(threadId, entry);
+    return entry;
+  }
+};
+
+// src/upstream/codex-rs/app-server/src/bespoke_event_handling.ts
+function apply_bespoke_event_handling(msg, context) {
+  return eventMsgToAppServerEvents(msg, context);
+}
+
+// src/upstream/codex-rs/app-server/src/runtime.ts
+function createCodexAppServerRuntime(options) {
+  const sessions = /* @__PURE__ */ new Map();
+  const serverRequestTargets = /* @__PURE__ */ new Map();
+  const threadStateManager = new ThreadStateManager();
+  const requestSerializationQueues = new RequestSerializationQueues();
+  const sendOutgoingMessage = options.sendOutgoingMessage ?? options.eventSink;
+  const outgoing = new OutgoingMessageSender({
+    send: async (message, messageContext) => {
+      if (options.sendOutgoingTransportMessage) {
+        await options.sendOutgoingTransportMessage(message, {
+          connectionIds: messageContext.connectionIds,
+          context: messageContext.context,
+          threadId: messageContext.threadId
+        });
+        return;
+      }
+      const event = outgoingMessageToAppServerEvent(message);
+      if (event && sendOutgoingMessage) {
+        await sendOutgoingMessage(event, {
+          context: messageContext.context,
+          threadId: messageContext.threadId ?? threadIdFromAppServerEvent(event)
+        });
+      }
+    }
+  });
+  async function emit(threadId, event, context) {
+    if (event.type === "server_notification") {
+      await outgoing.sendServerNotification(event.notification, context, threadId);
+      return;
+    }
+    if (event.type === "server_request") {
+      const handle = outgoing.sendRequestWithHandle(
+        event.request,
+        threadId,
+        context
+      );
+      const coreTarget = "coreTarget" in event ? event.coreTarget : void 0;
+      if (coreTarget) {
+        serverRequestTargets.set(
+          serverRequestTargetKey(threadId, handle.request.id),
+          coreTarget
+        );
+      }
+      void handle.result.catch((error) => {
+        options.onRuntimeError?.(error, { context, threadId });
+      });
+      return;
+    }
+    await sendOutgoingMessage?.(event, { context, threadId });
+  }
+  function emitCoreEvent(threadId, event, context) {
+    if (event.msg.type === "session_configured") {
+      return;
+    }
+    const threadState = threadStateManager.threadState(threadId);
+    const tracked = threadState.trackCurrentTurnEvent(event.id, event.msg);
+    const protocolEvents = apply_bespoke_event_handling(event.msg, {
+      activeTurn: tracked.activeTurn,
+      terminalTurn: tracked.terminalTurn,
+      threadId,
+      turnId: "turn_id" in event.msg && typeof event.msg.turn_id === "string" ? event.msg.turn_id : event.id
+    });
+    for (const protocolEvent of protocolEvents) {
+      void emit(threadId, protocolEvent, context);
+    }
+  }
+  const sessionFactory = new CodexSessionFactory({
+    buildSessionConfiguration: options.buildSessionConfiguration,
+    createSession: options.createSession,
+    emitCoreEvent,
+    mcpConnectionManager: options.mcpConnectionManager,
+    store: options.store
+  });
+  const createSession = (threadId, params, context, submission) => sessionFactory.createSession({ context, params, submission, threadId });
+  const taskRunner = new CodexSessionTaskRunner({
+    createModelClient: options.createModelClient,
+    modelClientCacheKey: options.modelClientCacheKey,
+    onRuntimeError: options.onRuntimeError,
+    runInBackground: options.runInBackground,
+    store: options.store
+  });
+  const threadProcessor = new ThreadRequestProcessor({
+    buildCreateThreadParams: options.buildCreateThreadParams,
+    createSession,
+    emit,
+    resolveDynamicTools: options.resolveDynamicTools,
+    sessions,
+    store: options.store,
+    taskRunner
+  });
+  const turnProcessor = new TurnRequestProcessor({
+    createSession,
+    onRuntimeError: options.onRuntimeError,
+    sessions,
+    taskRunner
+  });
+  const mcpProcessor = new McpRequestProcessor({
+    mcpConnectionManager: options.mcpConnectionManager,
+    mcpServerOauthLogin: options.mcpServerOauthLogin,
+    reloadMcpServers: options.reloadMcpServers,
+    runInBackground: options.runConnectionBackground,
+    store: options.store
+  });
+  const methodHandlers = {
+    configMcpServerReload: (params, context) => mcpProcessor.mcpServerRefresh(params, context),
+    mcpResourceRead: (params, context, request) => mcpProcessor.mcpResourceRead(params, context, request),
+    mcpServerOauthLogin: (params, context) => mcpProcessor.mcpServerOauthLogin(params, context),
+    mcpServerStatusList: (params, context, request) => mcpProcessor.mcpServerStatusList(params, context, request),
+    mcpServerToolCall: (params, context, request) => mcpProcessor.mcpServerToolCall(params, context, request),
+    threadStart: (params, context) => threadProcessor.threadStart(params, context),
+    threadResume: (params, context) => threadProcessor.threadResume(params, context),
+    threadList: (params) => threadProcessor.threadList(params),
+    threadRead: (params) => threadProcessor.threadRead(params),
+    threadNameSet: (params, context) => threadProcessor.threadNameSet(params, context),
+    threadArchive: (params, context) => threadProcessor.threadArchive(params, context),
+    threadUnarchive: (params, context) => threadProcessor.threadUnarchive(params, context),
+    threadMetadataUpdate: (params) => threadProcessor.threadMetadataUpdate(params),
+    threadCompactStart: (params, context) => threadProcessor.threadCompactStart(params, context),
+    turnStart: (params, context) => turnProcessor.turnStart(params, context),
+    turnSteer: (params, context) => turnProcessor.turnSteer(params, context),
+    turnInterrupt: (params) => turnProcessor.turnInterrupt(params)
+  };
+  function createMessageProcessor(input) {
+    return new CodexAppServerMessageProcessor({
+      connectionId: input.connectionId,
+      handlers: input.initialize ? { ...methodHandlers, initialize: input.initialize } : methodHandlers,
+      initializeResponse: input.initializeResponse,
+      outgoing,
+      requestSerializationQueues,
+      session: input.session
+    });
+  }
+  async function resolveServerRequest(params) {
+    const threadId = asThreadId(String(params.threadId));
+    const targetKey = serverRequestTargetKey(threadId, params.requestId);
+    const request = outgoing.pendingRequestsForThread(threadId).find(
+      (candidate) => candidate.id === params.requestId
+    ) ?? null;
+    if (!request) {
+      serverRequestTargets.delete(targetKey);
+    }
+    const target = request ? serverRequestResponseTarget(serverRequestTargets.get(targetKey) ?? null) : null;
+    const submission = submissionFromServerRequestResult({
+      request,
+      requestId: params.requestId,
+      result: params.result,
+      target
+    });
+    await submitServerRequestResponse(threadId, submission);
+    serverRequestTargets.delete(targetKey);
+    await outgoing.notifyClientResponse(params.requestId, params.result);
+    await emit(threadId, serverRequestResolvedNotification({
+      requestId: params.requestId,
+      threadId
+    }));
+  }
+  async function connectionClosed(connectionId) {
+    const emptyThreadIds = threadStateManager.removeConnection(connectionId);
+    outgoing.connectionClosed(connectionId);
+    for (const threadId of emptyThreadIds) {
+      threadStateManager.removeThreadState(threadId);
+    }
+  }
+  function connectionInitialized(connectionId) {
+    threadStateManager.connectionInitialized(connectionId);
+  }
+  async function rejectServerRequest(params) {
+    const threadId = asThreadId(String(params.threadId));
+    const targetKey = serverRequestTargetKey(threadId, params.requestId);
+    const request = outgoing.pendingRequestsForThread(threadId).find(
+      (candidate) => candidate.id === params.requestId
+    ) ?? null;
+    if (!request) {
+      serverRequestTargets.delete(targetKey);
+    }
+    const target = request ? serverRequestResponseTarget(serverRequestTargets.get(targetKey) ?? null) : null;
+    const submission = submissionFromServerRequestError({
+      error: params.error,
+      request,
+      requestId: params.requestId,
+      target
+    });
+    await submitServerRequestResponse(threadId, submission);
+    serverRequestTargets.delete(targetKey);
+    await outgoing.notifyClientError(params.requestId, params.error);
+    await emit(threadId, serverRequestResolvedNotification({
+      requestId: params.requestId,
+      threadId
+    }));
+  }
+  async function submitServerRequestResponse(threadId, submission) {
+    if (!isServerRequestResponseSubmission(submission)) {
+      throw new Error("Only server-request response submissions can be routed through CodexAppServerRuntime.");
+    }
+    const runtimeSession = sessions.get(threadId);
+    if (!runtimeSession) {
+      throw new Error("Codex thread has no active turn for this server request response.");
+    }
+    await runtimeSession.session.submit_with_id(submission);
+  }
+  return {
+    connectionClosed,
+    connectionInitialized,
+    createMessageProcessor,
+    methodHandlers,
+    rejectServerRequest,
+    resolveServerRequest
+  };
+}
+function serverRequestTargetKey(threadId, requestId) {
+  return `${threadId}:${String(requestId)}`;
+}
+function serverRequestResponseTarget(target) {
+  if (!target) {
+    return null;
+  }
+  return target;
+}
+function threadIdFromAppServerEvent(event) {
+  if (event.type === "server_notification") {
+    const threadId = event.notification.params.threadId;
+    if (typeof threadId === "string") {
+      return asThreadId(threadId);
+    }
+  }
+  if (event.type === "server_request") {
+    const threadId = event.request.params.threadId;
+    if (typeof threadId === "string") {
+      return asThreadId(threadId);
+    }
+  }
+  return asThreadId("00000000-0000-4000-8000-000000000000");
+}
+
+export { CodexAppServerConnectionSessionState, CodexAppServerMessageProcessor, CodexAppServerRequestError, CodexSessionFactory, CodexSessionTaskRunner, ConnectionRpcGate, ConnectionRpcGateClosedError, McpRequestProcessor, OutgoingMessageSender, RequestSerializationQueues, ThreadRequestProcessor, ThreadScopedOutgoingMessageSender, ThreadState, ThreadStateManager, TurnRequestProcessor, appServerUserInputToCoreUserInput, apply_bespoke_event_handling, approvalPolicyString, codexAppServerDeferredResponse, coreDynamicToolResponseFromAppServerResponse, createCodexAppServerRuntime, decodeDynamicToolCallResponse, defaultId, errorToJsonRpcError, fallbackDynamicToolCallResponse, isServerRequestResponseSubmission, jsonRpcError, jsonRpcInternalError, jsonRpcInvalidRequestError, jsonRpcParseError, last_token_info_from_rollout_items, latest_token_usage_turn_id, latest_token_usage_turn_id_from_rollout_items, outgoingMessageToAppServerEvent, parseClientTransportPayload, parseJsonRpcMessage, parseJsonRpcTransportPayload, parseServerTransportPayload, queuedOutgoingMessage, requestSerializationQueueKeyFromScope, serializeJsonRpcError, serializeJsonRpcResponse, serializeOutgoingMessage, steerErrorCode, submissionFromServerRequestError, submissionFromServerRequestResult, threadIdFromStartParams, thread_token_usage_updated_notification_from_info, thread_token_usage_updated_notification_from_rollout_items, unsupportedMethodError, valueOrNull };
+//# sourceMappingURL=chunk-V4BMZWBM.js.map
+//# sourceMappingURL=chunk-V4BMZWBM.js.map