@jrkropp/codex-js 0.1.4 → 0.3.0

package/dist/chunk-V4BMZWBM.js

@@ -1,2401 +0,0 @@
-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