@jrkropp/codex-js 0.1.2 → 0.1.3

package/dist/chunk-2DZRMCI2.js

@@ -0,0 +1,1258 @@
+import { renderThreadFromHistory } from './chunk-DYLHN3HG.js';
+
+// src/upstream/codex-rs/app-server-protocol/src/protocol/event-mapping.ts
+function eventMsgToAppServerEvents(msg, context) {
+  if (msg.type === "token_count") {
+    const events = [];
+    const turnId = turnIdFromEventMsg(msg, context);
+    if (msg.info) {
+      events.push(
+        turnId ? notification({
+          method: "thread/tokenUsage/updated",
+          params: {
+            threadId: context.threadId,
+            turnId,
+            tokenUsage: threadTokenUsageFromTokenUsageInfo(msg.info)
+          }
+        }) : missingTurnIdWarning(context.threadId, msg.type)
+      );
+    }
+    if (msg.rate_limits) {
+      events.push(notification({
+        method: "account/rateLimits/updated",
+        params: {
+          rateLimits: appServerRateLimitSnapshot(msg.rate_limits)
+        }
+      }));
+    }
+    return events;
+  }
+  if (msg.type === "dynamic_tool_call_request") {
+    const threadId = context.threadId;
+    return [
+      notification({
+        method: "item/started",
+        params: {
+          threadId,
+          turnId: msg.turn_id,
+          startedAtMs: msg.started_at_ms ?? Date.now(),
+          item: {
+            type: "dynamicToolCall",
+            id: msg.call_id,
+            namespace: msg.namespace ?? null,
+            tool: msg.tool,
+            arguments: msg.arguments,
+            status: "inProgress",
+            contentItems: null,
+            success: null,
+            durationMs: null
+          }
+        }
+      }),
+      request(
+        {
+          method: "item/tool/call",
+          params: {
+            threadId,
+            turnId: msg.turn_id,
+            callId: msg.call_id,
+            namespace: msg.namespace ?? null,
+            tool: msg.tool,
+            arguments: msg.arguments
+          }
+        },
+        { type: "dynamic_tool", callId: msg.call_id }
+      )
+    ];
+  }
+  if (msg.type === "agent_message") {
+    return [];
+  }
+  return [eventMsgToAppServerEvent(msg, context)];
+}
+function eventMsgToAppServerEvent(msg, context) {
+  const threadId = context.threadId;
+  const turnId = turnIdFromEventMsg(msg, context);
+  switch (msg.type) {
+    case "turn_started":
+      return notification({
+        method: "turn/started",
+        params: {
+          threadId,
+          turn: {
+            ...context.activeTurn ?? {},
+            id: msg.turn_id,
+            items: [],
+            itemsView: "notLoaded",
+            status: "inProgress",
+            error: null,
+            startedAt: epochSeconds(msg.started_at),
+            completedAt: null,
+            durationMs: null
+          }
+        }
+      });
+    case "turn_complete":
+      return notification({
+        method: "turn/completed",
+        params: {
+          threadId,
+          turn: completedTurnFromEvent({
+            completedAt: epochSeconds(msg.completed_at),
+            durationMs: msg.duration_ms ?? null,
+            fallbackTurnId: msg.turn_id,
+            status: "completed",
+            terminalTurn: context.terminalTurn
+          })
+        }
+      });
+    case "turn_aborted":
+      return notification({
+        method: "turn/completed",
+        params: {
+          threadId,
+          turn: completedTurnFromEvent({
+            completedAt: epochSeconds(msg.completed_at ?? msg.aborted_at),
+            durationMs: msg.duration_ms ?? null,
+            fallbackTurnId: msg.turn_id,
+            status: "interrupted",
+            terminalTurn: context.terminalTurn
+          })
+        }
+      });
+    case "agent_message_content_delta":
+      return notification({
+        method: "item/agentMessage/delta",
+        params: {
+          threadId: msg.thread_id,
+          turnId: msg.turn_id,
+          itemId: msg.item_id,
+          delta: msg.delta
+        }
+      });
+    case "plan_delta":
+      return notification({
+        method: "item/plan/delta",
+        params: {
+          threadId: msg.thread_id,
+          turnId: msg.turn_id,
+          itemId: msg.item_id,
+          delta: msg.delta
+        }
+      });
+    case "plan_update":
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      return notification({
+        method: "turn/plan/updated",
+        params: {
+          threadId,
+          turnId,
+          explanation: msg.explanation ?? null,
+          plan: msg.plan.map((step) => ({
+            step: step.step,
+            status: step.status === "in_progress" ? "inProgress" : step.status
+          }))
+        }
+      });
+    case "item_started": {
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      const item = coreTurnItemToThreadItem(msg.item);
+      return item ? notification({
+        method: "item/started",
+        params: {
+          threadId,
+          turnId: msg.turn_id ?? turnId,
+          item,
+          startedAtMs: Date.now()
+        }
+      }) : warning(threadId, `Unmapped Codex item_started: ${msg.item.type}`);
+    }
+    case "item_completed": {
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      const item = coreTurnItemToThreadItem(msg.item);
+      return item ? notification({
+        method: "item/completed",
+        params: {
+          threadId,
+          turnId: msg.turn_id ?? turnId,
+          item,
+          completedAtMs: Date.now()
+        }
+      }) : warning(threadId, `Unmapped Codex item_completed: ${msg.item.type}`);
+    }
+    case "user_message":
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      return notification({
+        method: "item/completed",
+        params: {
+          threadId,
+          turnId,
+          completedAtMs: Date.now(),
+          item: {
+            type: "userMessage",
+            id: `user-${turnId}`,
+            content: userInputsFromUserMessage(msg)
+          }
+        }
+      });
+    case "raw_response_item":
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      return notification({
+        method: "rawResponseItem/completed",
+        params: {
+          threadId,
+          turnId,
+          item: msg.item
+        }
+      });
+    case "request_user_input":
+      return request(
+        {
+          method: "item/tool/requestUserInput",
+          params: {
+            threadId,
+            turnId: msg.turn_id,
+            itemId: msg.call_id,
+            questions: msg.questions.map((question) => ({
+              id: question.id,
+              header: question.header,
+              question: question.question,
+              isOther: question.isOther,
+              isSecret: question.isSecret,
+              options: question.options.map((option) => ({ ...option }))
+            }))
+          }
+        },
+        { type: "user_input", responseId: msg.turn_id }
+      );
+    case "request_permissions":
+      return request(
+        {
+          method: "item/permissions/requestApproval",
+          params: {
+            threadId,
+            turnId: msg.turn_id,
+            itemId: msg.call_id,
+            cwd: msg.cwd ?? "",
+            reason: msg.reason ?? null,
+            permissions: msg.permissions
+          }
+        },
+        { type: "request_permissions", callId: msg.call_id }
+      );
+    case "command_approval_request":
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      return request({
+        method: "item/commandExecution/requestApproval",
+        params: {
+          threadId,
+          turnId,
+          itemId: msg.call_id,
+          approvalId: null,
+          reason: msg.reason ?? null,
+          command: msg.command.join(" "),
+          cwd: msg.cwd,
+          commandActions: [],
+          networkApprovalContext: null,
+          proposedExecpolicyAmendment: null,
+          proposedNetworkPolicyAmendments: null
+        }
+      });
+    case "file_change_approval_request":
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      return request({
+        method: "item/fileChange/requestApproval",
+        params: {
+          threadId,
+          turnId,
+          itemId: msg.call_id,
+          reason: msg.reason ?? null,
+          grantRoot: null
+        }
+      });
+    case "dynamic_tool_call_request":
+      return request(
+        {
+          method: "item/tool/call",
+          params: {
+            threadId,
+            turnId: msg.turn_id,
+            callId: msg.call_id,
+            namespace: msg.namespace ?? null,
+            tool: msg.tool,
+            arguments: msg.arguments
+          }
+        },
+        { type: "dynamic_tool", callId: msg.call_id }
+      );
+    case "dynamic_tool_call_response":
+      return notification({
+        method: "item/completed",
+        params: {
+          threadId,
+          turnId: msg.turn_id,
+          completedAtMs: msg.completed_at_ms ?? Date.now(),
+          item: {
+            type: "dynamicToolCall",
+            id: msg.call_id,
+            namespace: msg.namespace ?? null,
+            tool: msg.tool,
+            arguments: msg.arguments,
+            status: msg.success ? "completed" : "failed",
+            contentItems: msg.content_items.map(
+              (item) => item.type === "inputText" ? { type: "inputText", text: item.text } : { type: "inputImage", imageUrl: item.imageUrl }
+            ),
+            success: msg.success,
+            durationMs: durationMsFromString(msg.duration)
+          }
+        }
+      });
+    case "mcp_server_elicitation_request":
+      return request(
+        {
+          method: "mcpServer/elicitation/request",
+          params: {
+            threadId,
+            turnId: msg.turn_id,
+            serverName: msg.server_name,
+            ...msg.request.type === "url" ? {
+              mode: "url",
+              message: msg.request.message,
+              _meta: msg.request.meta ?? null,
+              url: msg.request.url,
+              elicitationId: msg.request.elicitation_id ?? ""
+            } : {
+              mode: "form",
+              message: msg.request.message,
+              _meta: msg.request.meta ?? null,
+              requestedSchema: msg.request.requested_schema
+            }
+          }
+        },
+        {
+          type: "mcp_elicitation",
+          serverName: msg.server_name,
+          requestId: msg.id
+        }
+      );
+    case "context_compacted":
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      return notification({
+        method: "thread/compacted",
+        params: { threadId, turnId }
+      });
+    case "realtime_conversation_started":
+      return notification({
+        method: "thread/realtime/started",
+        params: {
+          threadId,
+          realtimeSessionId: msg.realtime_session_id ?? null,
+          version: msg.version
+        }
+      });
+    case "realtime_conversation_sdp":
+      return notification({
+        method: "thread/realtime/sdp",
+        params: { threadId, sdp: msg.sdp }
+      });
+    case "realtime_conversation_realtime":
+      if (typeof msg.payload === "object" && msg.payload !== null && msg.payload.type === "error") {
+        return notification({
+          method: "thread/realtime/error",
+          params: {
+            threadId,
+            message: String(
+              msg.payload.message ?? "Realtime conversation error."
+            )
+          }
+        });
+      }
+      return notification({
+        method: "thread/realtime/itemAdded",
+        params: {
+          threadId,
+          item: msg.payload
+        }
+      });
+    case "realtime_conversation_closed":
+      return notification({
+        method: "thread/realtime/closed",
+        params: { threadId, reason: msg.reason ?? null }
+      });
+    case "warning":
+      return warning(threadId, msg.message);
+    case "error":
+      if (!turnId) {
+        return missingTurnIdWarning(threadId, msg.type);
+      }
+      return notification({
+        method: "error",
+        params: {
+          threadId,
+          turnId,
+          willRetry: false,
+          error: {
+            message: msg.message,
+            codexErrorInfo: null,
+            additionalDetails: null
+          }
+        }
+      });
+    default:
+      return warning(threadId, `Unmapped Codex event: ${msg.type}`);
+  }
+}
+var eventMsgToServerProtocolEvent = eventMsgToAppServerEvent;
+var eventMsgToServerProtocolEvents = eventMsgToAppServerEvents;
+function serverRequestResolvedNotification(input) {
+  return notification({
+    method: "serverRequest/resolved",
+    params: {
+      threadId: input.threadId,
+      requestId: input.requestId
+    }
+  });
+}
+function notification(notification2) {
+  return { notification: notification2, type: "server_notification" };
+}
+function request(request2, coreTarget) {
+  return {
+    ...coreTarget ? { coreTarget } : {},
+    request: request2,
+    type: "server_request"
+  };
+}
+function warning(threadId, message) {
+  return notification({
+    method: "warning",
+    params: { threadId, message }
+  });
+}
+function missingTurnIdWarning(threadId, eventType) {
+  return warning(threadId, `Codex event ${eventType} was missing a turn id.`);
+}
+function turnIdFromEventMsg(msg, context) {
+  if ("turn_id" in msg && typeof msg.turn_id === "string") {
+    return msg.turn_id;
+  }
+  return context.turnId ?? null;
+}
+function epochSeconds(value) {
+  return typeof value === "number" ? value / 1e3 : null;
+}
+function durationMsFromString(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function completedTurnFromEvent(input) {
+  const turn = input.terminalTurn?.id === input.fallbackTurnId ? input.terminalTurn : null;
+  return {
+    id: input.fallbackTurnId,
+    items: turn?.items ?? [],
+    itemsView: turn?.itemsView ?? "notLoaded",
+    status: turn?.status === "failed" && input.status === "completed" ? "failed" : input.status,
+    error: turn?.error ?? null,
+    startedAt: turn?.startedAt ?? null,
+    completedAt: input.completedAt,
+    durationMs: input.durationMs
+  };
+}
+function threadTokenUsageFromTokenUsageInfo(info) {
+  return {
+    total: appServerTokenUsageBreakdown(info.total_token_usage),
+    last: appServerTokenUsageBreakdown(info.last_token_usage),
+    modelContextWindow: info.model_context_window ?? null
+  };
+}
+function appServerTokenUsageBreakdown(usage) {
+  return {
+    totalTokens: usage.total_tokens,
+    inputTokens: usage.input_tokens,
+    cachedInputTokens: usage.cached_input_tokens,
+    outputTokens: usage.output_tokens,
+    reasoningOutputTokens: usage.reasoning_output_tokens
+  };
+}
+function appServerRateLimitSnapshot(snapshot) {
+  return {
+    limitId: valueAsStringOrNull(snapshot.limit_id),
+    limitName: valueAsStringOrNull(snapshot.limit_name),
+    primary: appServerRateLimitWindow(snapshot.primary),
+    secondary: appServerRateLimitWindow(snapshot.secondary),
+    credits: snapshot.credits ?? null,
+    planType: snapshot.plan_type ?? null,
+    rateLimitReachedType: snapshot.rate_limit_reached_type ?? null
+  };
+}
+function appServerRateLimitWindow(window) {
+  if (!window || typeof window !== "object") {
+    return null;
+  }
+  const record = window;
+  const resetSeconds = typeof record.reset_seconds === "number" ? record.reset_seconds : null;
+  const resetsAt = typeof record.resets_at === "number" ? record.resets_at : resetSeconds === null ? null : Math.floor(Date.now() / 1e3) + resetSeconds;
+  return {
+    usedPercent: numberOrZero(record.usedPercent ?? record.used_percent),
+    windowDurationMins: typeof record.windowDurationMins === "number" ? record.windowDurationMins : typeof record.window_duration_mins === "number" ? record.window_duration_mins : null,
+    resetsAt
+  };
+}
+function numberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function valueAsStringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function userInputsFromUserMessage(msg) {
+  const inputs = [
+    {
+      type: "text",
+      text: msg.message,
+      text_elements: appServerTextElementsFromCore(msg.text_elements ?? [])
+    }
+  ];
+  for (const url of msg.images ?? []) {
+    inputs.push({ type: "image", url });
+  }
+  for (const path of msg.local_images ?? []) {
+    inputs.push({ type: "localImage", path });
+  }
+  return inputs;
+}
+function appServerUserInputsFromCore(inputs) {
+  return inputs.map((input) => {
+    if (input.type === "text") {
+      return {
+        type: "text",
+        text: input.text,
+        text_elements: appServerTextElementsFromCore(input.text_elements ?? [])
+      };
+    }
+    if (input.type === "image") {
+      return { type: "image", url: input.image_url };
+    }
+    if (input.type === "local_image") {
+      return { type: "localImage", path: input.path };
+    }
+    return input;
+  });
+}
+function appServerTextElementsFromCore(elements) {
+  return elements.map((element) => ({
+    byteRange: element.byte_range,
+    placeholder: element.placeholder ?? null
+  }));
+}
+function appServerMessagePhase(value) {
+  return value === "commentary" || value === "final_answer" ? value : null;
+}
+function appServerMemoryCitationFromCore(citation) {
+  return citation ? {
+    entries: citation.entries,
+    threadIds: citation.rolloutIds ?? []
+  } : null;
+}
+function coreTurnItemToThreadItem(item) {
+  if (!item || typeof item !== "object" || !("type" in item)) {
+    return null;
+  }
+  const value = item;
+  switch (value.type) {
+    case "UserMessage":
+      return {
+        type: "userMessage",
+        id: String(value.id ?? ""),
+        content: appServerUserInputsFromCore(value.content ?? [])
+      };
+    case "AgentMessage":
+      return {
+        type: "agentMessage",
+        id: String(value.id ?? ""),
+        text: (value.content ?? []).map((part) => part.text ?? "").join(""),
+        phase: appServerMessagePhase(value.phase),
+        memoryCitation: appServerMemoryCitationFromCore(
+          value.memory_citation ?? null
+        )
+      };
+    case "Plan":
+      return {
+        type: "plan",
+        id: String(value.id ?? ""),
+        text: String(value.text ?? "")
+      };
+    case "Reasoning":
+      return {
+        type: "reasoning",
+        id: String(value.id ?? ""),
+        summary: value.summary_text ?? [],
+        content: value.raw_content ?? []
+      };
+    case "WebSearch": {
+      const action = appServerWebSearchAction(value.action);
+      return {
+        type: "webSearch",
+        id: String(value.id ?? ""),
+        query: typeof value.query === "string" ? value.query : webSearchActionDetail(action),
+        action
+      };
+    }
+    case "CommandExecution":
+      return {
+        type: "commandExecution",
+        id: String(value.id ?? ""),
+        command: (value.command ?? []).join(" "),
+        cwd: String(value.cwd ?? ""),
+        processId: null,
+        source: "agent",
+        status: commandStatusToAppServer(value.status),
+        commandActions: [],
+        aggregatedOutput: [value.stdout, value.stderr].filter(Boolean).join("") || null,
+        exitCode: typeof value.exit_code === "number" ? value.exit_code : null,
+        durationMs: typeof value.duration_ms === "number" ? value.duration_ms : null
+      };
+    case "FileChange":
+      return {
+        type: "fileChange",
+        id: String(value.id ?? ""),
+        changes: [],
+        status: value.status ?? "completed"
+      };
+    case "DynamicToolCall":
+      return {
+        type: "dynamicToolCall",
+        id: String(value.id ?? ""),
+        namespace: value.namespace ?? null,
+        tool: String(value.tool ?? ""),
+        arguments: value.arguments ?? null,
+        status: dynamicToolStatusToAppServer(value.status),
+        contentItems: value.content_items ?? null,
+        success: value.success ?? null,
+        durationMs: durationMsFromString(value.duration)
+      };
+    case "ContextCompaction":
+      return {
+        type: "contextCompaction",
+        id: String(value.id ?? "")
+      };
+    default:
+      return null;
+  }
+}
+function appServerWebSearchAction(action) {
+  if (!action || typeof action !== "object") {
+    return { type: "other" };
+  }
+  const record = action;
+  if (record.type === "search") {
+    return {
+      type: "search",
+      query: typeof record.query === "string" ? record.query : null,
+      queries: Array.isArray(record.queries) ? record.queries.filter((query) => typeof query === "string") : null
+    };
+  }
+  if (record.type === "open_page" || record.type === "openPage") {
+    return {
+      type: "openPage",
+      url: typeof record.url === "string" ? record.url : null
+    };
+  }
+  if (record.type === "find_in_page" || record.type === "findInPage") {
+    return {
+      type: "findInPage",
+      url: typeof record.url === "string" ? record.url : null,
+      pattern: typeof record.pattern === "string" ? record.pattern : null
+    };
+  }
+  return { type: "other" };
+}
+function webSearchActionDetail(action) {
+  switch (action.type) {
+    case "search":
+      return action.query ?? action.queries?.join(", ") ?? "";
+    case "openPage":
+      return action.url ?? "";
+    case "findInPage": {
+      const pattern = action.pattern ?? "";
+      const url = action.url ?? "";
+      return pattern && url ? `'${pattern}' in ${url}` : pattern || url;
+    }
+    case "other":
+      return "";
+  }
+}
+function commandStatusToAppServer(value) {
+  if (value === "completed" || value === "failed") {
+    return value;
+  }
+  if (value === "cancelled") {
+    return "failed";
+  }
+  return "inProgress";
+}
+function dynamicToolStatusToAppServer(value) {
+  if (value === "completed" || value === "failed") {
+    return value;
+  }
+  return "inProgress";
+}
+
+// src/upstream/codex-rs/app-server-protocol/src/protocol/thread-resume.ts
+function buildThreadResumeResponseFromHistory(input) {
+  const thread = threadHistoryToAppServerThread(input);
+  return {
+    thread,
+    model: input.thread.model ?? "gpt-5.4",
+    modelProvider: input.thread.model_provider,
+    serviceTier: null,
+    cwd: input.thread.cwd,
+    instructionSources: [],
+    approvalPolicy: approvalPolicyFromStoredThread(input.thread),
+    approvalsReviewer: "user",
+    sandbox: sandboxPolicyFromStoredThread(input.thread),
+    reasoningEffort: reasoningEffortFromStoredThread(input.thread)
+  };
+}
+function threadHistoryToAppServerThread(input) {
+  const rendered = renderThreadFromHistory(input.history);
+  return {
+    id: input.thread.thread_id,
+    sessionId: input.thread.rollout_path ?? input.thread.thread_id,
+    forkedFromId: input.thread.forked_from_id ?? null,
+    preview: input.thread.preview,
+    ephemeral: false,
+    modelProvider: input.thread.model_provider,
+    createdAt: epochSecondsFromIso(input.thread.created_at),
+    updatedAt: epochSecondsFromIso(input.thread.updated_at),
+    status: { type: "idle" },
+    path: input.thread.rollout_path ?? null,
+    cwd: input.thread.cwd,
+    cliVersion: input.thread.cli_version ?? "",
+    source: sessionSourceFromStoredThread(input.thread.source),
+    threadSource: threadSourceFromStoredThread(input.thread.thread_source),
+    agentNickname: input.thread.agent_nickname ?? null,
+    agentRole: input.thread.agent_role ?? null,
+    gitInfo: gitInfoFromStoredThread(input.thread.git_info),
+    name: input.thread.name ?? null,
+    turns: rendered.turns.map(appServerTurnFromCoreTurn)
+  };
+}
+function renderableHistoryFromAppServerThread(thread) {
+  return {
+    thread_id: thread.id,
+    items: thread.turns.flatMap((turn) => {
+      const items = [
+        {
+          type: "event_msg",
+          payload: {
+            type: "turn_started",
+            turn_id: turn.id,
+            started_at: typeof turn.startedAt === "number" ? turn.startedAt * 1e3 : void 0
+          }
+        },
+        ...turn.items.map((item) => rolloutItemFromThreadItem(item, turn.id)).filter((item) => item !== null)
+      ];
+      if (turn.status === "inProgress") {
+        return items;
+      }
+      return [
+        ...items,
+        {
+          type: "event_msg",
+          payload: turn.status === "interrupted" ? {
+            type: "turn_aborted",
+            turn_id: turn.id,
+            reason: "interrupted",
+            completed_at: typeof turn.completedAt === "number" ? turn.completedAt * 1e3 : void 0,
+            duration_ms: turn.durationMs
+          } : {
+            type: "turn_complete",
+            turn_id: turn.id,
+            completed_at: typeof turn.completedAt === "number" ? turn.completedAt * 1e3 : void 0,
+            duration_ms: turn.durationMs
+          }
+        }
+      ];
+    })
+  };
+}
+function appServerTurnFromCoreTurn(turn) {
+  return {
+    id: turn.id,
+    items: turn.items.map(coreTurnItemToThreadItem).filter((item) => item !== null),
+    itemsView: turn.items_view === "not_loaded" ? "notLoaded" : turn.items_view,
+    status: coreTurnStatusToAppServer(turn.status),
+    error: turn.error ? {
+      message: turn.error.message,
+      codexErrorInfo: turn.error.codex_error_info ?? null,
+      additionalDetails: turn.error.additional_details ?? null
+    } : null,
+    startedAt: epochSeconds2(turn.started_at),
+    completedAt: epochSeconds2(turn.completed_at),
+    durationMs: turn.duration_ms
+  };
+}
+function rolloutItemFromThreadItem(item, turnId) {
+  const coreItem = coreTurnItemFromThreadItem(item);
+  if (!coreItem) {
+    return null;
+  }
+  return {
+    type: "event_msg",
+    payload: {
+      type: "item_completed",
+      turn_id: turnId,
+      item: coreItem
+    }
+  };
+}
+function coreTurnItemFromThreadItem(item) {
+  switch (item.type) {
+    case "userMessage":
+      return {
+        type: "UserMessage",
+        id: item.id,
+        content: item.content.map((input) => {
+          if (input.type === "image") {
+            return { type: "image", image_url: input.url };
+          }
+          if (input.type === "localImage") {
+            return { type: "local_image", path: input.path };
+          }
+          if (input.type !== "text") {
+            return {
+              type: "text",
+              text: input.name,
+              text_elements: []
+            };
+          }
+          return {
+            type: "text",
+            text: input.text,
+            text_elements: input.text_elements.map((element) => ({
+              byte_range: element.byteRange,
+              placeholder: element.placeholder ?? void 0
+            }))
+          };
+        })
+      };
+    case "agentMessage":
+      return {
+        type: "AgentMessage",
+        id: item.id,
+        content: [{ type: "Text", text: item.text }],
+        phase: item.phase,
+        memory_citation: item.memoryCitation ? {
+          entries: item.memoryCitation.entries,
+          rolloutIds: item.memoryCitation.threadIds
+        } : null
+      };
+    case "plan":
+      return { type: "Plan", id: item.id, text: item.text };
+    case "reasoning":
+      return {
+        type: "Reasoning",
+        id: item.id,
+        summary_text: item.summary,
+        raw_content: item.content
+      };
+    case "webSearch":
+      return {
+        type: "WebSearch",
+        id: item.id,
+        query: item.query,
+        action: coreWebSearchActionFromAppServer(item.action)
+      };
+    case "commandExecution":
+      return {
+        type: "CommandExecution",
+        id: item.id,
+        command: [item.command],
+        cwd: item.cwd,
+        status: coreCommandStatusFromAppServer(item.status),
+        stdout: item.aggregatedOutput ?? "",
+        exit_code: item.exitCode,
+        duration_ms: item.durationMs
+      };
+    case "fileChange":
+      return {
+        type: "FileChange",
+        id: item.id,
+        changes: {},
+        status: item.status === "completed" || item.status === "failed" || item.status === "declined" ? item.status : null,
+        auto_approved: false,
+        stdout: "",
+        stderr: ""
+      };
+    case "dynamicToolCall":
+      return {
+        type: "DynamicToolCall",
+        id: item.id,
+        namespace: item.namespace,
+        tool: item.tool,
+        arguments: item.arguments,
+        status: item.status,
+        content_items: item.contentItems ?? [],
+        success: item.success,
+        duration: item.durationMs === null ? null : String(item.durationMs)
+      };
+    case "contextCompaction":
+      return { type: "ContextCompaction", id: item.id };
+    default:
+      return null;
+  }
+}
+function coreWebSearchActionFromAppServer(action) {
+  if (!action) {
+    return { type: "other" };
+  }
+  switch (action.type) {
+    case "search":
+      return {
+        type: "search",
+        ...action.query ? { query: action.query } : {},
+        ...action.queries ? { queries: action.queries } : {}
+      };
+    case "openPage":
+      return {
+        type: "open_page",
+        ...action.url ? { url: action.url } : {}
+      };
+    case "findInPage":
+      return {
+        type: "find_in_page",
+        ...action.url ? { url: action.url } : {},
+        ...action.pattern ? { pattern: action.pattern } : {}
+      };
+    case "other":
+      return { type: "other" };
+  }
+}
+function coreTurnStatusToAppServer(status) {
+  if (status === "in_progress") {
+    return "inProgress";
+  }
+  return status;
+}
+function coreCommandStatusFromAppServer(status) {
+  if (status === "declined") {
+    return "failed";
+  }
+  return status === "inProgress" ? "in_progress" : status;
+}
+function epochSeconds2(value) {
+  return typeof value === "number" ? value / 1e3 : null;
+}
+function epochSecondsFromIso(value) {
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? Math.floor(parsed / 1e3) : 0;
+}
+function sessionSourceFromStoredThread(source) {
+  if (source === "cli" || source === "vscode" || source === "exec" || source === "unknown") {
+    return source;
+  }
+  if (source === "appServer" || source === "app-server") {
+    return "appServer";
+  }
+  return { custom: source };
+}
+function threadSourceFromStoredThread(source) {
+  if (source === "user" || source === "subagent" || source === "memory_consolidation") {
+    return source;
+  }
+  return null;
+}
+function gitInfoFromStoredThread(gitInfo) {
+  if (!gitInfo || typeof gitInfo !== "object") {
+    return null;
+  }
+  const value = gitInfo;
+  return {
+    sha: typeof value.sha === "string" ? value.sha : typeof value.commit_hash === "string" ? value.commit_hash : null,
+    branch: typeof value.branch === "string" ? value.branch : null,
+    originUrl: typeof value.originUrl === "string" ? value.originUrl : typeof value.repository_url === "string" ? value.repository_url : null
+  };
+}
+function approvalPolicyFromStoredThread(thread) {
+  if (thread.approval_mode === "untrusted" || thread.approval_mode === "on-failure" || thread.approval_mode === "on-request" || thread.approval_mode === "never") {
+    return thread.approval_mode;
+  }
+  return "on-request";
+}
+function sandboxPolicyFromStoredThread(thread) {
+  if (thread.sandbox_policy && typeof thread.sandbox_policy === "object") {
+    return thread.sandbox_policy;
+  }
+  if (thread.sandbox_policy === "read-only") {
+    return { type: "readOnly", networkAccess: false };
+  }
+  return { type: "dangerFullAccess" };
+}
+function reasoningEffortFromStoredThread(thread) {
+  if (thread.reasoning_effort === "none" || thread.reasoning_effort === "minimal" || thread.reasoning_effort === "low" || thread.reasoning_effort === "medium" || thread.reasoning_effort === "high" || thread.reasoning_effort === "xhigh") {
+    return thread.reasoning_effort;
+  }
+  return null;
+}
+
+// src/upstream/codex-rs/app-server-protocol/src/protocol/common.ts
+function clientRequestId(request2) {
+  return request2.id;
+}
+function clientRequestMethod(request2) {
+  return request2.method;
+}
+function clientRequestExperimentalReason(request2) {
+  return EXPERIMENTAL_METHOD_REASONS[request2.method] ?? clientRequestParamExperimentalReason(request2.method, objectParams(request2.params));
+}
+function clientRequestSerializationScope(request2) {
+  const params = objectParams(request2.params);
+  switch (request2.method) {
+    case "thread/resume":
+    case "thread/fork":
+      return threadOrPathScope(params, "threadId", "path");
+    case "thread/archive":
+    case "thread/unsubscribe":
+    case "thread/increment_elicitation":
+    case "thread/decrement_elicitation":
+    case "thread/name/set":
+    case "thread/goal/set":
+    case "thread/goal/get":
+    case "thread/goal/clear":
+    case "thread/metadata/update":
+    case "thread/memoryMode/set":
+    case "thread/unarchive":
+    case "thread/compact/start":
+    case "thread/shellCommand":
+    case "thread/approveGuardianDeniedAction":
+    case "thread/backgroundTerminals/clean":
+    case "thread/rollback":
+    case "thread/read":
+    case "thread/inject_items":
+    case "turn/start":
+    case "turn/steer":
+    case "turn/interrupt":
+    case "thread/realtime/start":
+    case "thread/realtime/appendAudio":
+    case "thread/realtime/appendText":
+    case "thread/realtime/stop":
+    case "review/start":
+    case "mcpServer/tool/call":
+      return threadScope(params, "threadId", "thread_id");
+    case "memory/reset":
+      return globalScope("memory");
+    case "skills/list":
+    case "hooks/list":
+    case "marketplace/add":
+    case "marketplace/remove":
+    case "marketplace/upgrade":
+    case "plugin/list":
+    case "plugin/read":
+    case "plugin/skill/read":
+    case "plugin/share/save":
+    case "plugin/share/updateTargets":
+    case "plugin/share/list":
+    case "plugin/share/delete":
+    case "skills/config/write":
+    case "plugin/install":
+    case "plugin/uninstall":
+    case "experimentalFeature/list":
+    case "experimentalFeature/enablement/set":
+    case "windowsSandbox/readiness":
+    case "config/read":
+    case "externalAgentConfig/detect":
+    case "externalAgentConfig/import":
+    case "config/value/write":
+    case "config/batchWrite":
+    case "configRequirements/read":
+      return globalScope("config");
+    case "device/key/create":
+    case "device/key/public":
+    case "device/key/sign":
+      return globalScope("device-key");
+    case "mcpServer/oauth/login":
+      return mcpOauthScope(params, "name");
+    case "config/mcpServer/reload":
+    case "mcpServerStatus/list":
+      return globalScope("mcp-registry");
+    case "mcpServer/resource/read":
+      return optionalThreadScope(params, "threadId", "thread_id");
+    case "windowsSandbox/setupStart":
+      return globalScope("windows-sandbox-setup");
+    case "account/login/start":
+    case "account/login/cancel":
+    case "account/logout":
+    case "account/sendAddCreditsNudgeEmail":
+    case "account/read":
+    case "getAuthStatus":
+      return globalScope("account-auth");
+    case "command/exec":
+      return optionalCommandExecProcessScope(params, "processId", "process_id");
+    case "command/exec/write":
+    case "command/exec/terminate":
+    case "command/exec/resize":
+      return commandExecProcessScope(params, "processId", "process_id");
+    case "process/spawn":
+    case "process/writeStdin":
+    case "process/kill":
+    case "process/resizePty":
+      return processHandleScope(params, "processHandle", "process_handle");
+    case "fuzzyFileSearch/sessionStart":
+    case "fuzzyFileSearch/sessionUpdate":
+    case "fuzzyFileSearch/sessionStop":
+      return fuzzySessionScope(params, "sessionId", "session_id");
+    case "fs/watch":
+    case "fs/unwatch":
+      return fsWatchScope(params, "watchId", "watch_id");
+    default:
+      return null;
+  }
+}
+var EXPERIMENTAL_METHOD_REASONS = {
+  "collaborationMode/list": "collaborationMode/list",
+  "fuzzyFileSearch/sessionStart": "fuzzyFileSearch/sessionStart",
+  "fuzzyFileSearch/sessionStop": "fuzzyFileSearch/sessionStop",
+  "fuzzyFileSearch/sessionUpdate": "fuzzyFileSearch/sessionUpdate",
+  "memory/reset": "memory/reset",
+  "mock/experimentalMethod": "mock/experimentalMethod",
+  "process/kill": "process/kill",
+  "process/resizePty": "process/resizePty",
+  "process/spawn": "process/spawn",
+  "process/writeStdin": "process/writeStdin",
+  "thread/backgroundTerminals/clean": "thread/backgroundTerminals/clean",
+  "thread/decrement_elicitation": "thread/decrement_elicitation",
+  "thread/goal/clear": "thread/goal/clear",
+  "thread/goal/get": "thread/goal/get",
+  "thread/goal/set": "thread/goal/set",
+  "thread/increment_elicitation": "thread/increment_elicitation",
+  "thread/memoryMode/set": "thread/memoryMode/set",
+  "thread/realtime/appendAudio": "thread/realtime/appendAudio",
+  "thread/realtime/appendText": "thread/realtime/appendText",
+  "thread/realtime/listVoices": "thread/realtime/listVoices",
+  "thread/realtime/start": "thread/realtime/start",
+  "thread/realtime/stop": "thread/realtime/stop",
+  "thread/turns/list": "thread/turns/list"
+};
+function clientRequestParamExperimentalReason(method, params) {
+  switch (method) {
+    case "thread/start":
+      return granularApprovalReason(params) ?? presentFieldReason(params, "thread/start.permissions", "permissions") ?? presentFieldReason(params, "thread/start.environments", "environments") ?? presentFieldReason(params, "thread/start.dynamicTools", "dynamicTools", "dynamic_tools") ?? presentFieldReason(params, "thread/start.mockExperimentalField", "mockExperimentalField", "mock_experimental_field") ?? truthyFieldReason(params, "thread/start.experimentalRawEvents", "experimentalRawEvents", "experimental_raw_events") ?? truthyFieldReason(params, "thread/start.persistFullHistory", "persistExtendedHistory", "persist_extended_history");
+    case "thread/resume":
+      return presentFieldReason(params, "thread/resume.history", "history") ?? presentFieldReason(params, "thread/resume.path", "path") ?? granularApprovalReason(params) ?? presentFieldReason(params, "thread/resume.permissions", "permissions") ?? truthyFieldReason(params, "thread/resume.excludeTurns", "excludeTurns", "exclude_turns") ?? truthyFieldReason(params, "thread/resume.persistFullHistory", "persistExtendedHistory", "persist_extended_history");
+    case "thread/fork":
+      return presentFieldReason(params, "thread/fork.path", "path") ?? granularApprovalReason(params) ?? presentFieldReason(params, "thread/fork.permissions", "permissions") ?? truthyFieldReason(params, "thread/fork.excludeTurns", "excludeTurns", "exclude_turns") ?? truthyFieldReason(params, "thread/fork.persistFullHistory", "persistExtendedHistory", "persist_extended_history");
+    case "turn/start":
+      return presentFieldReason(params, "turn/start.responsesapiClientMetadata", "responsesapiClientMetadata", "responsesapi_client_metadata") ?? presentFieldReason(params, "turn/start.environments", "environments") ?? granularApprovalReason(params) ?? presentFieldReason(params, "turn/start.permissions", "permissions") ?? presentFieldReason(params, "turn/start.collaborationMode", "collaborationMode", "collaboration_mode");
+    case "turn/steer":
+      return presentFieldReason(params, "turn/steer.responsesapiClientMetadata", "responsesapiClientMetadata", "responsesapi_client_metadata");
+    case "command/exec":
+      return presentFieldReason(params, "command/exec.permissionProfile", "permissionProfile", "permission_profile");
+    case "account/login/start":
+      return params.type === "chatgptAuthTokens" ? "account/login/start.chatgptAuthTokens" : null;
+    default:
+      return null;
+  }
+}
+function granularApprovalReason(params) {
+  const approvalPolicy = params.approvalPolicy ?? params.approval_policy;
+  return isRecord(approvalPolicy) && "granular" in approvalPolicy ? "askForApproval.granular" : null;
+}
+function presentFieldReason(params, reason, ...fields) {
+  for (const field of fields) {
+    if (params[field] !== void 0 && params[field] !== null) {
+      return reason;
+    }
+  }
+  return null;
+}
+function truthyFieldReason(params, reason, ...fields) {
+  for (const field of fields) {
+    if (params[field] === true) {
+      return reason;
+    }
+  }
+  return null;
+}
+function objectParams(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function globalScope(key) {
+  return { key, type: "global" };
+}
+function threadScope(params, ...fields) {
+  const threadId = stringField(params, ...fields);
+  return threadId ? { threadId, type: "thread" } : null;
+}
+function optionalThreadScope(params, ...fields) {
+  return threadScope(params, ...fields);
+}
+function threadOrPathScope(params, threadField, pathField) {
+  const threadId = stringField(params, threadField);
+  if (threadId) {
+    return { threadId, type: "thread" };
+  }
+  const path = stringField(params, pathField);
+  if (path) {
+    return { path, type: "threadPath" };
+  }
+  return threadId === "" ? { threadId, type: "thread" } : null;
+}
+function optionalCommandExecProcessScope(params, ...fields) {
+  const processId = stringField(params, ...fields);
+  return processId ? { processId, type: "commandExecProcess" } : null;
+}
+function commandExecProcessScope(params, ...fields) {
+  const processId = stringField(params, ...fields);
+  return processId ? { processId, type: "commandExecProcess" } : null;
+}
+function processHandleScope(params, ...fields) {
+  const processHandle = stringField(params, ...fields);
+  return processHandle ? { processHandle, type: "process" } : null;
+}
+function fuzzySessionScope(params, ...fields) {
+  const sessionId = stringField(params, ...fields);
+  return sessionId ? { sessionId, type: "fuzzyFileSearchSession" } : null;
+}
+function fsWatchScope(params, ...fields) {
+  const watchId = stringField(params, ...fields);
+  return watchId ? { watchId, type: "fsWatch" } : null;
+}
+function mcpOauthScope(params, ...fields) {
+  const serverName = stringField(params, ...fields);
+  return serverName ? { serverName, type: "mcpOauth" } : null;
+}
+function stringField(params, ...fields) {
+  for (const field of fields) {
+    const value = params[field];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return null;
+}
+
+export { appServerTurnFromCoreTurn, buildThreadResumeResponseFromHistory, clientRequestExperimentalReason, clientRequestId, clientRequestMethod, clientRequestSerializationScope, coreTurnItemToThreadItem, eventMsgToAppServerEvent, eventMsgToAppServerEvents, eventMsgToServerProtocolEvent, eventMsgToServerProtocolEvents, renderableHistoryFromAppServerThread, serverRequestResolvedNotification, threadHistoryToAppServerThread, threadTokenUsageFromTokenUsageInfo };
+//# sourceMappingURL=chunk-2DZRMCI2.js.map
+//# sourceMappingURL=chunk-2DZRMCI2.js.map