@jrkropp/codex-js 0.1.2 → 0.1.4

package/dist/chunk-6ZMJ34KE.js

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