@jrkropp/codex-js 0.1.4 → 0.2.0

package/dist/chunk-6ZMJ34KE.js

@@ -1,1153 +0,0 @@
-import { parseClientTransportPayload, serializeJsonRpcResponse, serializeJsonRpcError } from './chunk-V4BMZWBM.js';
-
-// src/upstream/codex-rs/app-server-client/src/session.ts
-var AppServerSession = class {
-  constructor(client) {
-    this.client = client;
-  }
-  client;
-  nextRequestIdValue = 1;
-  nextRequestId() {
-    const requestId = this.nextRequestIdValue;
-    this.nextRequestIdValue += 1;
-    return requestId;
-  }
-  nextEvent() {
-    return this.client.nextEvent?.() ?? Promise.resolve(null);
-  }
-  events() {
-    return this.client.events?.() ?? null;
-  }
-  requestTyped(request) {
-    return this.client.requestTyped(request);
-  }
-  initialize(params = defaultInitializeParams()) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "initialize",
-      params
-    });
-  }
-  threadStart(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/start",
-      params
-    });
-  }
-  threadResume(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/resume",
-      params
-    });
-  }
-  threadList(params = {}) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/list",
-      params
-    });
-  }
-  collaborationModeList(params = {}) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "collaborationMode/list",
-      params
-    });
-  }
-  configMcpServerReload() {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "config/mcpServer/reload",
-      params: void 0
-    });
-  }
-  mcpServerStatusList(params = {}) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "mcpServerStatus/list",
-      params
-    });
-  }
-  mcpResourceRead(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "mcpServer/resource/read",
-      params
-    });
-  }
-  mcpServerToolCall(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "mcpServer/tool/call",
-      params
-    });
-  }
-  mcpServerOauthLogin(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "mcpServer/oauth/login",
-      params
-    });
-  }
-  threadRead(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/read",
-      params
-    });
-  }
-  threadNameSet(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/name/set",
-      params
-    });
-  }
-  threadArchive(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/archive",
-      params
-    });
-  }
-  threadUnarchive(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/unarchive",
-      params
-    });
-  }
-  threadMetadataUpdate(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/metadata/update",
-      params
-    });
-  }
-  turnStart(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "turn/start",
-      params
-    });
-  }
-  turnSteer(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "turn/steer",
-      params
-    });
-  }
-  turnInterrupt(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "turn/interrupt",
-      params
-    });
-  }
-  threadCompactStart(params) {
-    return this.requestTyped({
-      id: this.nextRequestId(),
-      method: "thread/compact/start",
-      params
-    });
-  }
-  resolveServerRequest(requestId, result) {
-    return this.client.resolveServerRequest(requestId, result);
-  }
-  rejectServerRequest(requestId, error) {
-    return this.client.rejectServerRequest(requestId, error);
-  }
-};
-function defaultInitializeParams() {
-  return {
-    capabilities: {
-      experimentalApi: false,
-      optOutNotificationMethods: []
-    },
-    clientInfo: {
-      name: "codex-js",
-      title: null,
-      version: "0.0.0"
-    }
-  };
-}
-
-// src/upstream/codex-rs/app-server-client/src/pending_requests.ts
-var PendingAppServerRequests = class {
-  dynamicToolCalls = /* @__PURE__ */ new Map();
-  execApprovals = /* @__PURE__ */ new Map();
-  fileChangeApprovals = /* @__PURE__ */ new Map();
-  mcpRequests = /* @__PURE__ */ new Map();
-  permissionsApprovals = /* @__PURE__ */ new Map();
-  userInputs = /* @__PURE__ */ new Map();
-  clear() {
-    this.dynamicToolCalls.clear();
-    this.execApprovals.clear();
-    this.fileChangeApprovals.clear();
-    this.mcpRequests.clear();
-    this.permissionsApprovals.clear();
-    this.userInputs.clear();
-  }
-  noteServerRequest(request) {
-    switch (request.method) {
-      case "item/commandExecution/requestApproval": {
-        const id = request.params.approvalId ?? request.params.itemId;
-        this.execApprovals.set(id, request.id);
-        return null;
-      }
-      case "item/fileChange/requestApproval":
-        this.fileChangeApprovals.set(request.params.itemId, request.id);
-        return null;
-      case "item/permissions/requestApproval":
-        this.permissionsApprovals.set(request.params.itemId, request.id);
-        return null;
-      case "item/tool/requestUserInput": {
-        const queue = this.userInputs.get(request.params.turnId) ?? [];
-        queue.push({
-          itemId: request.params.itemId,
-          requestId: request.id
-        });
-        this.userInputs.set(request.params.turnId, queue);
-        return null;
-      }
-      case "mcpServer/elicitation/request":
-        this.mcpRequests.set(
-          mcpRequestKey(request.params.serverName, request.id),
-          request.id
-        );
-        return null;
-      case "item/tool/call":
-        this.dynamicToolCalls.set(request.params.callId, request.id);
-        return null;
-      default:
-        return {
-          message: `Unsupported Codex app-server request: ${request.method}`,
-          requestId: request.id
-        };
-    }
-  }
-  takeCommandExecutionApprovalResolution(id, response) {
-    return takeMapResolution(this.execApprovals, id, response);
-  }
-  takeFileChangeApprovalResolution(id, response) {
-    return takeMapResolution(this.fileChangeApprovals, id, response);
-  }
-  takePermissionsApprovalResolution(id, response) {
-    return takeMapResolution(this.permissionsApprovals, id, response);
-  }
-  takeDynamicToolCallResolution(callId, response) {
-    return takeMapResolution(this.dynamicToolCalls, callId, response);
-  }
-  takeUserInputResolution(turnId, response) {
-    const pending = this.popUserInputRequestForTurn(turnId);
-    return pending ? { requestId: pending.requestId, result: response } : null;
-  }
-  takeMcpElicitationResolution(serverName, requestId, response) {
-    return takeMapResolution(
-      this.mcpRequests,
-      mcpRequestKey(serverName, requestId),
-      response
-    );
-  }
-  resolveNotification(requestId) {
-    const execApproval = removeValue(this.execApprovals, requestId);
-    if (execApproval) {
-      return { id: execApproval, type: "exec_approval" };
-    }
-    const fileChangeApproval = removeValue(
-      this.fileChangeApprovals,
-      requestId
-    );
-    if (fileChangeApproval) {
-      return { id: fileChangeApproval, type: "file_change_approval" };
-    }
-    const permissionsApproval = removeValue(
-      this.permissionsApprovals,
-      requestId
-    );
-    if (permissionsApproval) {
-      return { id: permissionsApproval, type: "permissions_approval" };
-    }
-    const userInput = this.removeUserInputRequest(requestId);
-    if (userInput) {
-      return { itemId: userInput.itemId, type: "user_input" };
-    }
-    const dynamicToolCall = removeValue(this.dynamicToolCalls, requestId);
-    if (dynamicToolCall) {
-      return { callId: dynamicToolCall, type: "dynamic_tool_call" };
-    }
-    const mcpRequest = removeValue(this.mcpRequests, requestId);
-    if (mcpRequest) {
-      const [serverName] = mcpRequest.split(":");
-      return { requestId, serverName, type: "mcp_elicitation" };
-    }
-    return null;
-  }
-  containsServerRequest(request) {
-    return this.requestIds().some((requestId) => requestId === request.id);
-  }
-  requestIds() {
-    return [
-      ...this.execApprovals.values(),
-      ...this.fileChangeApprovals.values(),
-      ...this.permissionsApprovals.values(),
-      ...this.dynamicToolCalls.values(),
-      ...this.mcpRequests.values(),
-      ...Array.from(this.userInputs.values()).flatMap(
-        (queue) => queue.map((request) => request.requestId)
-      )
-    ];
-  }
-  popUserInputRequestForTurn(turnId) {
-    const queue = this.userInputs.get(turnId);
-    const pending = queue?.shift() ?? null;
-    if (queue && queue.length === 0) {
-      this.userInputs.delete(turnId);
-    }
-    return pending;
-  }
-  removeUserInputRequest(requestId) {
-    for (const [turnId, queue] of this.userInputs) {
-      const index = queue.findIndex((pending2) => pending2.requestId === requestId);
-      if (index === -1) {
-        continue;
-      }
-      const [pending] = queue.splice(index, 1);
-      if (queue.length === 0) {
-        this.userInputs.delete(turnId);
-      }
-      return pending ?? null;
-    }
-    return null;
-  }
-};
-function takeMapResolution(map, key, result) {
-  const requestId = map.get(key);
-  if (requestId === void 0) {
-    return null;
-  }
-  map.delete(key);
-  return { requestId, result };
-}
-function removeValue(map, value) {
-  for (const [key, current] of map) {
-    if (current === value) {
-      map.delete(key);
-      return key;
-    }
-  }
-  return null;
-}
-function mcpRequestKey(serverName, requestId) {
-  return `${serverName}:${requestId}`;
-}
-
-// src/upstream/codex-rs/app-server-client/src/thread_event_store.ts
-var ThreadEventStore = class _ThreadEventStore {
-  accountRateLimits = null;
-  activeTurnIds = /* @__PURE__ */ new Set();
-  bufferedEvents = [];
-  connectionStatus = "idle";
-  errors = [];
-  pendingRequests = /* @__PURE__ */ new Map();
-  resolvedRequestIds = [];
-  thread = null;
-  tokenUsage = null;
-  turns = [];
-  warnings = [];
-  static fromThread(thread) {
-    const store = new _ThreadEventStore();
-    store.setThread(thread);
-    return store;
-  }
-  applyNotification(notification) {
-    applyServerNotificationToThreadEventStore(this, notification);
-    return this.snapshot();
-  }
-  applyRequest(request) {
-    applyServerRequestToThreadEventStore(this, request);
-    return this.snapshot();
-  }
-  setConnectionStatus(status) {
-    this.connectionStatus = status;
-    return this.snapshot();
-  }
-  setThread(thread) {
-    this.thread = cloneThread(thread);
-    this.turns = thread.turns.map(cloneTurn);
-    this.activeTurnIds = new Set(
-      this.turns.filter((turn) => turn.status === "inProgress").map((turn) => turn.id)
-    );
-    return this.snapshot();
-  }
-  snapshot() {
-    return {
-      activeTurnIds: [...this.activeTurnIds],
-      accountRateLimits: this.accountRateLimits ? { ...this.accountRateLimits } : null,
-      bufferedEvents: [...this.bufferedEvents],
-      connectionStatus: this.connectionStatus,
-      errors: [...this.errors],
-      pendingRequests: [...this.pendingRequests.values()],
-      resolvedRequestIds: [...this.resolvedRequestIds],
-      thread: this.thread ? cloneThread(this.thread) : null,
-      tokenUsage: this.tokenUsage ? {
-        ...this.tokenUsage,
-        tokenUsage: cloneThreadTokenUsage(this.tokenUsage.tokenUsage)
-      } : null,
-      turns: this.turns.map(cloneTurn),
-      warnings: [...this.warnings]
-    };
-  }
-  noteNotification(notification) {
-    this.bufferedEvents = [...this.bufferedEvents, { notification, type: "notification" }];
-    switch (notification.method) {
-      case "thread/started":
-        this.setThread(notification.params.thread);
-        return;
-      case "thread/status/changed":
-        if (this.thread) {
-          this.thread = { ...this.thread, status: notification.params.status };
-        }
-        return;
-      case "thread/name/updated":
-        if (this.thread) {
-          this.thread = { ...this.thread, name: notification.params.threadName ?? null };
-        }
-        return;
-      case "thread/archived":
-      case "thread/unarchived":
-      case "thread/closed":
-      case "thread/goal/updated":
-      case "thread/goal/cleared":
-        return;
-      case "thread/tokenUsage/updated":
-        this.tokenUsage = {
-          threadId: notification.params.threadId,
-          tokenUsage: cloneThreadTokenUsage(notification.params.tokenUsage),
-          turnId: notification.params.turnId,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        return;
-      case "turn/started":
-        this.upsertTurn(notification.params.turn);
-        this.activeTurnIds.add(notification.params.turn.id);
-        return;
-      case "turn/diff/updated":
-      case "turn/plan/updated":
-        this.ensureTurn(notification.params.turnId);
-        return;
-      case "turn/completed":
-        this.upsertTurn(notification.params.turn);
-        this.activeTurnIds.delete(notification.params.turn.id);
-        if (notification.params.turn.error?.message) {
-          this.errors = appendUnique(this.errors, notification.params.turn.error.message);
-        }
-        return;
-      case "item/started":
-      case "item/completed":
-        this.upsertItem(notification.params.turnId, notification.params.item);
-        return;
-      case "item/agentMessage/delta":
-        this.applyAgentMessageDelta(
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.delta
-        );
-        return;
-      case "item/plan/delta":
-        this.applyPlanDelta(
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.delta
-        );
-        return;
-      case "item/reasoning/summaryPartAdded":
-        this.applyReasoningSummaryPartAdded(
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.summaryIndex
-        );
-        return;
-      case "item/reasoning/summaryTextDelta":
-        this.applyReasoningSummaryTextDelta(
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.summaryIndex,
-          notification.params.delta
-        );
-        return;
-      case "item/reasoning/textDelta":
-        this.applyReasoningTextDelta(
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.contentIndex,
-          notification.params.delta
-        );
-        return;
-      case "item/commandExecution/outputDelta":
-        this.applyCommandOutputDelta(
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.delta
-        );
-        return;
-      case "item/fileChange/outputDelta":
-        this.ensureTurn(notification.params.turnId);
-        return;
-      case "item/fileChange/patchUpdated":
-        this.applyFileChangePatchUpdated(
-          notification.params.turnId,
-          notification.params.itemId,
-          notification.params.changes
-        );
-        return;
-      case "item/mcpToolCall/progress":
-      case "item/commandExecution/terminalInteraction":
-      case "command/exec/outputDelta":
-      case "process/outputDelta":
-      case "process/exited":
-      case "rawResponseItem/completed":
-      case "hook/started":
-      case "hook/completed":
-      case "item/autoApprovalReview/started":
-      case "item/autoApprovalReview/completed":
-        return;
-      case "thread/compacted":
-        this.upsertItem(notification.params.turnId, {
-          id: `compacted-${notification.params.turnId}`,
-          type: "contextCompaction"
-        });
-        return;
-      case "serverRequest/resolved":
-        this.pendingRequests.delete(notification.params.requestId);
-        this.resolvedRequestIds = appendUnique(
-          this.resolvedRequestIds,
-          notification.params.requestId
-        );
-        return;
-      case "warning":
-        this.warnings = appendUnique(this.warnings, notification.params.message);
-        return;
-      case "error":
-        this.errors = appendUnique(this.errors, notification.params.error.message);
-        return;
-      case "guardianWarning":
-        this.warnings = appendUnique(this.warnings, notification.params.message);
-        return;
-      case "deprecationNotice":
-        this.warnings = appendUnique(this.warnings, notification.params.summary);
-        return;
-      case "configWarning":
-        this.warnings = appendUnique(this.warnings, notification.params.summary);
-        return;
-      case "account/rateLimits/updated":
-        this.accountRateLimits = { ...notification.params.rateLimits };
-        return;
-      case "thread/realtime/started":
-      case "thread/realtime/itemAdded":
-      case "thread/realtime/transcript/delta":
-      case "thread/realtime/transcript/done":
-      case "thread/realtime/outputAudio/delta":
-      case "thread/realtime/sdp":
-      case "thread/realtime/error":
-      case "thread/realtime/closed":
-      case "fs/changed":
-      case "model/rerouted":
-      case "model/verification":
-      case "mcpServer/oauthLogin/completed":
-      case "mcpServer/startupStatus/updated":
-      case "fuzzyFileSearch/sessionUpdated":
-      case "fuzzyFileSearch/sessionCompleted":
-      case "windows/worldWritableWarning":
-      case "windowsSandbox/setupCompleted":
-        return;
-      default:
-        if (notificationThreadId(notification)) {
-          this.warnings = appendUnique(
-            this.warnings,
-            `Unsupported Codex app-server notification: ${notification.method}`
-          );
-        }
-        return;
-    }
-  }
-  noteRequest(request) {
-    this.bufferedEvents = [...this.bufferedEvents, { request, type: "request" }];
-    this.pendingRequests.set(request.id, request);
-  }
-  upsertTurn(turn) {
-    const index = this.turns.findIndex((candidate) => candidate.id === turn.id);
-    if (index === -1) {
-      this.turns = [...this.turns, cloneTurn(turn)];
-      return;
-    }
-    const current = this.turns[index];
-    this.turns = replaceAt(this.turns, index, {
-      ...current,
-      ...turn,
-      items: turn.items.length > 0 ? turn.items.map(cloneThreadItem) : current.items
-    });
-  }
-  upsertItem(turnId, item) {
-    const turn = this.ensureTurn(turnId);
-    const itemIndex = turn.items.findIndex((candidate) => candidate.id === item.id);
-    const nextItems = itemIndex === -1 ? [...turn.items, cloneThreadItem(item)] : replaceAt(turn.items, itemIndex, cloneThreadItem(item));
-    this.replaceTurn({ ...turn, items: nextItems, itemsView: "full" });
-  }
-  applyAgentMessageDelta(turnId, itemId, delta) {
-    const turn = this.ensureTurn(turnId);
-    const item = turn.items.find((candidate) => candidate.id === itemId);
-    if (item?.type === "agentMessage") {
-      this.upsertItem(turnId, { ...item, text: `${item.text}${delta}` });
-      return;
-    }
-    this.upsertItem(turnId, {
-      id: itemId,
-      memoryCitation: null,
-      phase: "commentary",
-      text: delta,
-      type: "agentMessage"
-    });
-  }
-  applyPlanDelta(turnId, itemId, delta) {
-    const turn = this.ensureTurn(turnId);
-    const item = turn.items.find((candidate) => candidate.id === itemId);
-    if (item?.type === "plan") {
-      this.upsertItem(turnId, { ...item, text: `${item.text}${delta}` });
-      return;
-    }
-    this.upsertItem(turnId, {
-      id: itemId,
-      text: delta,
-      type: "plan"
-    });
-  }
-  applyReasoningSummaryPartAdded(turnId, itemId, summaryIndex) {
-    const item = this.reasoningItem(turnId, itemId);
-    const summary = replaceAtOrAppend(item.summary, summaryIndex, "");
-    this.upsertItem(turnId, { ...item, summary });
-  }
-  applyReasoningSummaryTextDelta(turnId, itemId, summaryIndex, delta) {
-    const item = this.reasoningItem(turnId, itemId);
-    const current = item.summary[summaryIndex] ?? "";
-    const summary = replaceAtOrAppend(item.summary, summaryIndex, `${current}${delta}`);
-    this.upsertItem(turnId, { ...item, summary });
-  }
-  applyReasoningTextDelta(turnId, itemId, contentIndex, delta) {
-    const item = this.reasoningItem(turnId, itemId);
-    const current = item.content[contentIndex] ?? "";
-    const content = replaceAtOrAppend(item.content, contentIndex, `${current}${delta}`);
-    this.upsertItem(turnId, { ...item, content });
-  }
-  applyCommandOutputDelta(turnId, itemId, delta) {
-    const turn = this.ensureTurn(turnId);
-    const item = turn.items.find((candidate) => candidate.id === itemId);
-    if (item?.type !== "commandExecution") {
-      return;
-    }
-    this.upsertItem(turnId, {
-      ...item,
-      aggregatedOutput: `${item.aggregatedOutput ?? ""}${delta}`
-    });
-  }
-  applyFileChangePatchUpdated(turnId, itemId, changes) {
-    const turn = this.ensureTurn(turnId);
-    const item = turn.items.find((candidate) => candidate.id === itemId);
-    if (item?.type !== "fileChange") {
-      return;
-    }
-    this.upsertItem(turnId, { ...item, changes });
-  }
-  reasoningItem(turnId, itemId) {
-    const turn = this.ensureTurn(turnId);
-    const item = turn.items.find((candidate) => candidate.id === itemId);
-    if (item?.type === "reasoning") {
-      return item;
-    }
-    return {
-      content: [],
-      id: itemId,
-      summary: [],
-      type: "reasoning"
-    };
-  }
-  ensureTurn(turnId) {
-    const existing = this.turns.find((turn2) => turn2.id === turnId);
-    if (existing) {
-      return existing;
-    }
-    const turn = {
-      completedAt: null,
-      durationMs: null,
-      error: null,
-      id: turnId,
-      items: [],
-      itemsView: "full",
-      startedAt: null,
-      status: "inProgress"
-    };
-    this.turns = [...this.turns, turn];
-    this.activeTurnIds.add(turnId);
-    return turn;
-  }
-  replaceTurn(turn) {
-    const index = this.turns.findIndex((candidate) => candidate.id === turn.id);
-    this.turns = index === -1 ? [...this.turns, turn] : replaceAt(this.turns, index, turn);
-  }
-};
-function applyServerNotificationToThreadEventStore(store, notification) {
-  store.noteNotification(notification);
-  return store.snapshot();
-}
-function applyServerRequestToThreadEventStore(store, request) {
-  store.noteRequest(request);
-  return store.snapshot();
-}
-function serverRequestThreadId(request) {
-  if ("params" in request && request.params && typeof request.params === "object") {
-    const threadId = request.params.threadId;
-    return typeof threadId === "string" ? threadId : null;
-  }
-  return null;
-}
-function serverNotificationThreadTarget(notification) {
-  const threadId = notificationThreadId(notification);
-  if (!threadId) {
-    return { type: "global" };
-  }
-  return isUuidLike(threadId) ? { threadId, type: "thread" } : { threadId, type: "invalid_thread_id" };
-}
-function threadEventSnapshotHasStarted(snapshot) {
-  if (!snapshot) {
-    return false;
-  }
-  return snapshot.turns.some((turn) => turn.items.length > 0) || snapshot.activeTurnIds.length > 0 || snapshot.pendingRequests.length > 0 || snapshot.warnings.length > 0 || snapshot.errors.length > 0;
-}
-function notificationThreadId(notification) {
-  if (notification.method === "thread/started") {
-    return notification.params.thread.id;
-  }
-  if ("params" in notification && notification.params && typeof notification.params === "object") {
-    const threadId = notification.params.threadId;
-    return typeof threadId === "string" ? threadId : null;
-  }
-  return null;
-}
-function cloneThread(thread) {
-  return {
-    ...thread,
-    turns: thread.turns.map(cloneTurn)
-  };
-}
-function cloneTurn(turn) {
-  return {
-    ...turn,
-    items: turn.items.map(cloneThreadItem)
-  };
-}
-function cloneThreadItem(item) {
-  return { ...item };
-}
-function cloneThreadTokenUsage(tokenUsage) {
-  return {
-    last: { ...tokenUsage.last },
-    modelContextWindow: tokenUsage.modelContextWindow,
-    total: { ...tokenUsage.total }
-  };
-}
-function replaceAt(items, index, item) {
-  return [...items.slice(0, index), item, ...items.slice(index + 1)];
-}
-function replaceAtOrAppend(items, index, item) {
-  if (index < items.length) {
-    return replaceAt(items, index, item);
-  }
-  return [...items, item];
-}
-function appendUnique(items, item) {
-  return items.includes(item) ? [...items] : [...items, item];
-}
-function isUuidLike(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value);
-}
-
-// src/upstream/codex-rs/app-server-client/src/lib.ts
-async function requestTyped(request, send) {
-  try {
-    return await send(request);
-  } catch (source) {
-    if (isJsonRpcError(source)) {
-      throw {
-        method: request.method,
-        source,
-        type: "server"
-      };
-    }
-    throw {
-      method: request.method,
-      source,
-      type: "transport"
-    };
-  }
-}
-function serverNotificationRequiresDelivery(notification) {
-  return notification.method === "turn/completed" || notification.method === "item/completed" || notification.method === "item/agentMessage/delta" || notification.method === "item/plan/delta" || notification.method === "item/reasoning/summaryTextDelta" || notification.method === "item/reasoning/textDelta";
-}
-function requestMethodName(request) {
-  return request.method;
-}
-function isJsonRpcError(value) {
-  return typeof value === "object" && value !== null && typeof value.code === "number" && typeof value.message === "string";
-}
-
-// src/upstream/codex-rs/app-server-client/src/remote.ts
-var CodexAppServerClientTransportError = class extends Error {
-  constructor(message, status, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "CodexAppServerClientTransportError";
-  }
-  status;
-  body;
-};
-function createCodexAppServerClient(options) {
-  let socket = null;
-  let openPromise = null;
-  let initializePromise = null;
-  let initialized = false;
-  const pendingRequests = /* @__PURE__ */ new Map();
-  const eventQueue = createEventQueue();
-  async function ensureOpenSocket() {
-    const openState = 1;
-    if (socket?.readyState === openState) {
-      return socket;
-    }
-    openPromise ??= openSocket();
-    return openPromise;
-  }
-  async function ensureInitialized() {
-    if (initialized) {
-      return;
-    }
-    initializePromise ??= sendClientRequest({
-      id: 0,
-      method: "initialize",
-      params: await resolveInitializeParams(options.initializeParams)
-    });
-    await initializePromise;
-    initialized = true;
-  }
-  async function request(request2) {
-    if (request2.method !== "initialize") {
-      await ensureInitialized();
-      return sendClientRequest(request2);
-    }
-    const result = await sendClientRequest(request2);
-    initialized = true;
-    return result;
-  }
-  async function sendClientRequest(request2) {
-    const websocket = await ensureOpenSocket();
-    return new Promise((resolve, reject) => {
-      pendingRequests.set(request2.id, { reject, resolve });
-      try {
-        websocket.send(JSON.stringify(request2));
-      } catch (error) {
-        pendingRequests.delete(request2.id);
-        reject(error);
-      }
-    });
-  }
-  async function sendClientResponse(requestId, result) {
-    const websocket = await ensureOpenSocket();
-    websocket.send(serializeJsonRpcResponse(requestId, result));
-  }
-  async function sendClientError(requestId, error) {
-    const websocket = await ensureOpenSocket();
-    websocket.send(serializeJsonRpcError(requestId, error));
-  }
-  async function openSocket() {
-    options.onConnectionStatus?.("connecting");
-    eventQueue.reopen();
-    const WebSocketCtor = options.WebSocket ?? WebSocket;
-    const websocketUrl = await resolveUrl(options.url);
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      const nextSocket = new WebSocketCtor(websocketUrl);
-      socket = nextSocket;
-      nextSocket.addEventListener("open", () => {
-        settled = true;
-        options.onConnectionStatus?.("connected");
-        resolve(nextSocket);
-      });
-      nextSocket.addEventListener("message", (message) => {
-        handleSocketMessage(message.data);
-      });
-      nextSocket.addEventListener("close", () => {
-        const error = new CodexAppServerClientTransportError(
-          "Codex app-server WebSocket closed."
-        );
-        closeSocketState(error);
-        eventQueue.push({ message: "closed", type: "disconnected" });
-        eventQueue.close();
-        options.onConnectionStatus?.("closed");
-        if (!settled) {
-          reject(error);
-        }
-      });
-      nextSocket.addEventListener("error", () => {
-        const error = new CodexAppServerClientTransportError(
-          "Codex app-server WebSocket failed."
-        );
-        closeSocketState(error);
-        eventQueue.fail(error);
-        options.onConnectionStatus?.("error");
-        if (!settled) {
-          reject(error);
-        }
-      });
-    });
-  }
-  function handleSocketMessage(value) {
-    const parsed = parseClientTransportPayload(value);
-    if (parsed.type === "invalid") {
-      const event = options.parseEvent?.(value);
-      if (event) {
-        eventQueue.push(event);
-      }
-      return;
-    }
-    const message = parsed.message;
-    switch (message.type) {
-      case "response": {
-        const pending = pendingRequests.get(message.response.id);
-        if (!pending) {
-          return;
-        }
-        pendingRequests.delete(message.response.id);
-        pending.resolve(message.response.result);
-        return;
-      }
-      case "error": {
-        if (message.error.id === null) {
-          eventQueue.fail(message.error.error);
-          return;
-        }
-        const pending = pendingRequests.get(message.error.id);
-        if (!pending) {
-          return;
-        }
-        pendingRequests.delete(message.error.id);
-        pending.reject(message.error.error);
-        return;
-      }
-      case "server_notification":
-        eventQueue.push({
-          notification: message.notification,
-          type: "server_notification"
-        });
-        return;
-      case "server_request":
-        eventQueue.push({ request: message.request, type: "server_request" });
-        return;
-    }
-  }
-  function closeSocketState(error) {
-    socket = null;
-    openPromise = null;
-    initializePromise = null;
-    initialized = false;
-    for (const pending of pendingRequests.values()) {
-      pending.reject(error);
-    }
-    pendingRequests.clear();
-  }
-  function close() {
-    const currentSocket = socket;
-    closeSocketState(
-      new CodexAppServerClientTransportError(
-        "Codex app-server WebSocket closed."
-      )
-    );
-    eventQueue.close();
-    if (currentSocket && currentSocket.readyState !== 3) {
-      currentSocket.close();
-    }
-  }
-  return {
-    close,
-    events() {
-      void ensureInitialized().catch((error) => eventQueue.fail(error));
-      return eventQueue.iterable();
-    },
-    request,
-    requestTyped(clientRequest) {
-      return requestTyped(clientRequest, request);
-    },
-    rejectServerRequest(requestId, error) {
-      return sendClientError(requestId, error);
-    },
-    resolveServerRequest(requestId, result) {
-      return sendClientResponse(requestId, result);
-    }
-  };
-}
-function parseCodexAppServerEvent(value) {
-  const parsed = parseClientTransportPayload(value);
-  if (parsed.type === "ok") {
-    switch (parsed.message.type) {
-      case "server_notification":
-        return {
-          notification: parsed.message.notification,
-          type: "server_notification"
-        };
-      case "server_request":
-        return { request: parsed.message.request, type: "server_request" };
-      case "error":
-      case "response":
-        return null;
-    }
-  }
-  if (typeof value !== "string") {
-    return appServerEventFromParsed(value);
-  }
-  try {
-    return appServerEventFromParsed(JSON.parse(value));
-  } catch {
-    return null;
-  }
-}
-async function resolveInitializeParams(params) {
-  if (typeof params === "function") {
-    return params();
-  }
-  return params ?? defaultInitializeParams2();
-}
-async function resolveUrl(url) {
-  return typeof url === "function" ? await url() : url;
-}
-function defaultInitializeParams2() {
-  return {
-    capabilities: {
-      experimentalApi: false,
-      optOutNotificationMethods: []
-    },
-    clientInfo: {
-      name: "codex-js",
-      title: null,
-      version: "0.0.0"
-    }
-  };
-}
-function appServerEventFromParsed(value) {
-  if (isObject(value) && typeof value.type === "string") {
-    if (value.type === "server_notification" || value.type === "server_request" || value.type === "lagged" || value.type === "disconnected") {
-      return value;
-    }
-  }
-  if (isObject(value) && typeof value.method === "string" && "params" in value) {
-    if ("id" in value) {
-      return { request: value, type: "server_request" };
-    }
-    return {
-      notification: value,
-      type: "server_notification"
-    };
-  }
-  return null;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function createEventQueue() {
-  const values = [];
-  const waiters = [];
-  let closed = false;
-  let failure = null;
-  return {
-    close() {
-      closed = true;
-      for (const waiter of waiters.splice(0)) {
-        waiter.settled = true;
-        waiter.resolve({ done: true, value: void 0 });
-      }
-    },
-    fail(error) {
-      failure = error;
-      for (const waiter of waiters.splice(0)) {
-        waiter.settled = true;
-        waiter.reject(error);
-      }
-    },
-    push(value) {
-      while (waiters.length > 0) {
-        const waiter = waiters.shift();
-        if (waiter.settled) {
-          continue;
-        }
-        waiter.settled = true;
-        waiter.resolve({ done: false, value });
-        return;
-      }
-      values.push(value);
-    },
-    reopen() {
-      values.splice(0);
-      closed = false;
-      failure = null;
-    },
-    iterable(options = {}) {
-      return {
-        [Symbol.asyncIterator]() {
-          let active = true;
-          let pendingWaiter = null;
-          return {
-            next() {
-              if (!active) {
-                return Promise.resolve({ done: true, value: void 0 });
-              }
-              if (failure) {
-                return Promise.reject(failure);
-              }
-              if (values.length > 0) {
-                return Promise.resolve({
-                  done: false,
-                  value: values.shift()
-                });
-              }
-              if (closed) {
-                return Promise.resolve({ done: true, value: void 0 });
-              }
-              return new Promise((resolve, reject) => {
-                const waiter = { reject, resolve, settled: false };
-                pendingWaiter = waiter;
-                waiters.push(waiter);
-              });
-            },
-            return() {
-              options.onReturn?.();
-              active = false;
-              if (pendingWaiter && !pendingWaiter.settled) {
-                pendingWaiter.settled = true;
-                const index = waiters.indexOf(pendingWaiter);
-                if (index !== -1) {
-                  waiters.splice(index, 1);
-                }
-                pendingWaiter.resolve({ done: true, value: void 0 });
-              }
-              return Promise.resolve({ done: true, value: void 0 });
-            }
-          };
-        }
-      };
-    }
-  };
-}
-
-export { AppServerSession, CodexAppServerClientTransportError, PendingAppServerRequests, ThreadEventStore, createCodexAppServerClient, parseCodexAppServerEvent, requestMethodName, requestTyped, serverNotificationRequiresDelivery, serverNotificationThreadTarget, serverRequestThreadId, threadEventSnapshotHasStarted };
-//# sourceMappingURL=chunk-6ZMJ34KE.js.map
-//# sourceMappingURL=chunk-6ZMJ34KE.js.map