@jrkropp/codex-js 0.1.3 → 0.2.0

package/dist/internal/codex/app-server-client/src/lib.d.ts

@@ -0,0 +1,48 @@
+import type { ClientRequest, RequestId, ServerNotification, ServerRequest } from "../../app-server-protocol/schema/typescript/index.js";
+export type JsonRpcResult = unknown;
+export type JSONRPCErrorError = {
+    code: number;
+    data?: unknown;
+    message: string;
+};
+export type Result = JsonRpcResult;
+export type AppServerEvent = {
+    skipped: number;
+    type: "lagged";
+} | {
+    notification: ServerNotification;
+    type: "server_notification";
+} | {
+    request: ServerRequest;
+    type: "server_request";
+} | {
+    message: string;
+    type: "disconnected";
+};
+export type TypedRequestError = {
+    method: string;
+    source: unknown;
+    type: "transport";
+} | {
+    method: string;
+    source: JSONRPCErrorError;
+    type: "server";
+} | {
+    method: string;
+    source: unknown;
+    type: "deserialize";
+};
+export type AppServerRequestHandle = {
+    rejectServerRequest(requestId: RequestId, error: JSONRPCErrorError): Promise<void>;
+    request(request: ClientRequest): Promise<unknown>;
+    requestTyped<T>(request: ClientRequest): Promise<T>;
+    resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
+};
+export declare function requestTyped<T>(request: ClientRequest, send: (request: ClientRequest) => Promise<unknown>): Promise<T>;
+export declare function serverNotificationRequiresDelivery(notification: ServerNotification): boolean;
+export declare function requestMethodName(request: ClientRequest): string;
+export { CodexAppServerClientTransportError, createCodexAppServerClient, parseCodexAppServerEvent, type CodexAppServerClientConnectionStatus, type CodexAppServerClientOptions, } from "./remote.js";
+export { AppServerSession, type CodexAppServer } from "./session.js";
+export { PendingAppServerRequests, type AppServerRequestResolution, type ResolvedAppServerRequest, type UnsupportedAppServerRequest, } from "./pending_requests.js";
+export { applyServerNotificationToThreadEventStore, applyServerRequestToThreadEventStore, serverNotificationThreadTarget, serverRequestThreadId, threadEventSnapshotHasStarted, ThreadEventStore, type ServerNotificationThreadTarget, type ThreadBufferedEvent, type ThreadEventSnapshot, type ThreadTokenUsageSnapshot, } from "./thread_event_store.js";
+export { applyServerNotificationToRenderedThread, applyServerRequestToRenderedThread, renderThreadFromAppServerThread, serverNotificationToEventMsg, serverRequestToEventMsg, } from "./thread_projection.js";

package/dist/{index-77U_Oc-a.d.ts → internal/codex/app-server-client/src/pending_requests.d.ts}

@@ -1,24 +1,15 @@
-import './ThreadResumeResponse-DvmE1juU.js';
-import './TurnSteerResponse-0kBCfplh.js';
-import { R as RequestId } from './ToolRequestUserInputQuestion-CeZa5X1J.js';
-import { a as ServerRequest } from './ServerRequest-B5cKVJjr.js';
-import { R as Result } from './lib-nXlaKiS-.js';
-import './remote-ClZbq9KN.js';
-import './session-BRYzi8OT.js';
-import './thread_event_store-C0zYzukG.js';
-import { C as CommandExecutionRequestApprovalResponse, F as FileChangeRequestApprovalResponse, P as PermissionsRequestApprovalResponse, M as McpServerElicitationRequestResponse } from './PermissionsRequestApprovalResponse-DxzPPDRb.js';
-import { D as DynamicToolCallResponse } from './DynamicToolCallResponse-82DFjES2.js';
-import { T as ToolRequestUserInputResponse } from './ToolRequestUserInputResponse-zcPLwbiK.js';
-
-type AppServerRequestResolution = {
+import type { RequestId, ServerRequest } from "../../app-server-protocol/schema/typescript/index.js";
+import type { CommandExecutionRequestApprovalResponse, DynamicToolCallResponse, FileChangeRequestApprovalResponse, McpServerElicitationRequestResponse, PermissionsRequestApprovalResponse, ToolRequestUserInputResponse } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import type { Result } from "./lib.js";
+export type AppServerRequestResolution = {
     requestId: RequestId;
     result: Result;
 };
-type UnsupportedAppServerRequest = {
+export type UnsupportedAppServerRequest = {
     message: string;
     requestId: RequestId;
 };
-type ResolvedAppServerRequest = {
+export type ResolvedAppServerRequest = {
     id: string;
     type: "exec_approval";
 } | {
@@ -38,7 +29,7 @@ type ResolvedAppServerRequest = {
     callId: string;
     type: "dynamic_tool_call";
 };
-declare class PendingAppServerRequests {
+export declare class PendingAppServerRequests {
     private readonly dynamicToolCalls;
     private readonly execApprovals;
     private readonly fileChangeApprovals;
@@ -59,5 +50,3 @@ declare class PendingAppServerRequests {
     private popUserInputRequestForTurn;
     private removeUserInputRequest;
 }
-
-export { type AppServerRequestResolution as A, PendingAppServerRequests as P, type ResolvedAppServerRequest as R, type UnsupportedAppServerRequest as U };

package/dist/internal/codex/app-server-client/src/remote.d.ts

@@ -0,0 +1,18 @@
+import type { InitializeParams } from "../../app-server-protocol/schema/typescript/index.js";
+import type { AppServerEvent } from "./lib.js";
+import type { CodexAppServer } from "./session.js";
+export type CodexAppServerClientConnectionStatus = "connecting" | "connected" | "closed" | "error";
+export type CodexAppServerClientOptions = {
+    WebSocket?: typeof WebSocket;
+    initializeParams?: InitializeParams | (() => InitializeParams | Promise<InitializeParams>);
+    onConnectionStatus?: (status: CodexAppServerClientConnectionStatus) => void;
+    parseEvent?: (value: unknown) => AppServerEvent | null;
+    url: string | (() => string | Promise<string>);
+};
+export declare class CodexAppServerClientTransportError extends Error {
+    readonly status?: number | undefined;
+    readonly body?: unknown | undefined;
+    constructor(message: string, status?: number | undefined, body?: unknown | undefined);
+}
+export declare function createCodexAppServerClient(options: CodexAppServerClientOptions): CodexAppServer;
+export declare function parseCodexAppServerEvent(value: unknown): AppServerEvent | null;

package/dist/{session-BRYzi8OT.d.ts → internal/codex/app-server-client/src/session.d.ts}

@@ -1,9 +1,7 @@
-import { C as ClientRequest, I as InitializeParams, k as ThreadStartParams, h as ThreadResumeParams, i as ThreadResumeResponse, e as ThreadListParams, a as CollaborationModeListParams, L as ListMcpServerStatusParams, M as McpResourceReadParams, c as McpServerToolCallParams, b as McpServerOauthLoginParams, g as ThreadReadParams, j as ThreadSetNameParams, T as ThreadArchiveParams, l as ThreadUnarchiveParams, f as ThreadMetadataUpdateParams, n as TurnStartParams, o as TurnSteerParams, m as TurnInterruptParams, d as ThreadCompactStartParams } from './ThreadResumeResponse-DvmE1juU.js';
-import { I as InitializeResponse, l as ThreadStartResponse, h as ThreadListResponse, b as CollaborationModeListResponse, e as McpServerRefreshResponse, L as ListMcpServerStatusResponse, c as McpResourceReadResponse, f as McpServerToolCallResponse, d as McpServerOauthLoginResponse, j as ThreadReadResponse, k as ThreadSetNameResponse, T as ThreadArchiveResponse, m as ThreadUnarchiveResponse, i as ThreadMetadataUpdateResponse, o as TurnStartResponse, p as TurnSteerResponse, n as TurnInterruptResponse, g as ThreadCompactStartResponse } from './TurnSteerResponse-0kBCfplh.js';
-import { R as RequestId } from './ToolRequestUserInputQuestion-CeZa5X1J.js';
-import { A as AppServerEvent, J as JSONRPCErrorError, R as Result } from './lib-nXlaKiS-.js';
-
-type CodexAppServer = {
+import type { ClientRequest, InitializeParams, InitializeResponse, RequestId } from "../../app-server-protocol/schema/typescript/index.js";
+import type { CollaborationModeListParams, CollaborationModeListResponse, ListMcpServerStatusParams, ListMcpServerStatusResponse, McpResourceReadParams, McpResourceReadResponse, McpServerOauthLoginParams, McpServerOauthLoginResponse, McpServerRefreshResponse, McpServerToolCallParams, McpServerToolCallResponse, ThreadArchiveParams, ThreadArchiveResponse, ThreadCompactStartParams, ThreadCompactStartResponse, ThreadListParams, ThreadListResponse, ThreadMetadataUpdateParams, ThreadMetadataUpdateResponse, ThreadReadParams, ThreadReadResponse, ThreadResumeParams, ThreadResumeResponse, ThreadSetNameParams, ThreadSetNameResponse, ThreadStartParams, ThreadStartResponse, ThreadUnarchiveParams, ThreadUnarchiveResponse, TurnInterruptParams, TurnInterruptResponse, TurnStartParams, TurnStartResponse, TurnSteerParams, TurnSteerResponse } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import type { AppServerEvent, JSONRPCErrorError, Result } from "./lib.js";
+export type CodexAppServer = {
     close?(): void;
     events?(): AsyncIterable<AppServerEvent>;
     nextEvent?(): Promise<AppServerEvent | null>;
@@ -12,7 +10,7 @@ type CodexAppServer = {
     requestTyped<T>(request: ClientRequest): Promise<T>;
     resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
 };
-declare class AppServerSession {
+export declare class AppServerSession {
     private readonly client;
     private nextRequestIdValue;
     constructor(client: CodexAppServer);
@@ -42,5 +40,3 @@ declare class AppServerSession {
     resolveServerRequest(requestId: RequestId, result: Result): Promise<void>;
     rejectServerRequest(requestId: RequestId, error: JSONRPCErrorError): Promise<void>;
 }
-
-export { AppServerSession as A, type CodexAppServer as C };

package/dist/{thread_event_store-C0zYzukG.d.ts → internal/codex/app-server-client/src/thread_event_store.d.ts}

@@ -1,15 +1,15 @@
-import { R as RequestId } from './ToolRequestUserInputQuestion-CeZa5X1J.js';
-import { R as RateLimitSnapshot, S as ServerNotification, a as ServerRequest, T as Thread, d as ThreadTokenUsage, c as Turn } from './ServerRequest-B5cKVJjr.js';
-import { R as RenderedThreadConnectionStatus } from './rendered-thread-AOxw3V5b.js';
-
-type ThreadBufferedEvent = {
+import type { RequestId, ServerNotification, ServerRequest } from "../../app-server-protocol/schema/typescript/index.js";
+import type { Thread, ThreadTokenUsage, Turn } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import type { RateLimitSnapshot } from "../../app-server-protocol/schema/typescript/v2/RateLimitSnapshot.js";
+import type { RenderedThreadConnectionStatus } from "../../core/src/rendered-thread.js";
+export type ThreadBufferedEvent = {
     notification: ServerNotification;
     type: "notification";
 } | {
     request: ServerRequest;
     type: "request";
 };
-type ServerNotificationThreadTarget = {
+export type ServerNotificationThreadTarget = {
     threadId: string;
     type: "thread";
 } | {
@@ -18,7 +18,7 @@ type ServerNotificationThreadTarget = {
 } | {
     type: "global";
 };
-type ThreadEventSnapshot = {
+export type ThreadEventSnapshot = {
     activeTurnIds: string[];
     accountRateLimits: RateLimitSnapshot | null;
     bufferedEvents: ThreadBufferedEvent[];
@@ -31,13 +31,13 @@ type ThreadEventSnapshot = {
     turns: Turn[];
     warnings: string[];
 };
-type ThreadTokenUsageSnapshot = {
+export type ThreadTokenUsageSnapshot = {
     threadId: string;
     tokenUsage: ThreadTokenUsage;
     turnId: string;
     updatedAt: string;
 };
-declare class ThreadEventStore {
+export declare class ThreadEventStore {
     private accountRateLimits;
     private activeTurnIds;
     private bufferedEvents;
@@ -70,8 +70,8 @@ declare class ThreadEventStore {
     private ensureTurn;
     private replaceTurn;
 }
-declare function serverRequestThreadId(request: ServerRequest): string | null;
-declare function serverNotificationThreadTarget(notification: ServerNotification): ServerNotificationThreadTarget;
-declare function threadEventSnapshotHasStarted(snapshot: ThreadEventSnapshot | null): boolean;
-
-export { type ServerNotificationThreadTarget as S, type ThreadBufferedEvent as T, type ThreadEventSnapshot as a, ThreadEventStore as b, type ThreadTokenUsageSnapshot as c, serverRequestThreadId as d, serverNotificationThreadTarget as s, threadEventSnapshotHasStarted as t };
+export declare function applyServerNotificationToThreadEventStore(store: ThreadEventStore, notification: ServerNotification): ThreadEventSnapshot;
+export declare function applyServerRequestToThreadEventStore(store: ThreadEventStore, request: ServerRequest): ThreadEventSnapshot;
+export declare function serverRequestThreadId(request: ServerRequest): string | null;
+export declare function serverNotificationThreadTarget(notification: ServerNotification): ServerNotificationThreadTarget;
+export declare function threadEventSnapshotHasStarted(snapshot: ThreadEventSnapshot | null): boolean;

package/dist/internal/codex/app-server-client/src/thread_projection.d.ts

@@ -0,0 +1,9 @@
+import type { ServerNotification, ServerRequest } from "../../app-server-protocol/schema/typescript/index.js";
+import type { Thread } from "../../app-server-protocol/schema/typescript/v2/index.js";
+import { type RenderedThreadState } from "../../core/src/rendered-thread.js";
+import type { EventMsg } from "../../core/src/protocol.js";
+export declare function renderThreadFromAppServerThread(thread: Thread): RenderedThreadState;
+export declare function applyServerNotificationToRenderedThread(state: RenderedThreadState, notification: ServerNotification): RenderedThreadState;
+export declare function applyServerRequestToRenderedThread(state: RenderedThreadState, request: ServerRequest): RenderedThreadState;
+export declare function serverNotificationToEventMsg(notification: ServerNotification): EventMsg | null;
+export declare function serverRequestToEventMsg(request: ServerRequest): EventMsg | null;

package/dist/internal/codex/app-server-protocol/schema/typescript/AbsolutePathBuf.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A path that is guaranteed to be absolute and normalized (though it is not
+ * guaranteed to be canonicalized or exist on the filesystem).
+ *
+ * IMPORTANT: When deserializing an `AbsolutePathBuf`, a base path must be set
+ * using [AbsolutePathBufGuard::new]. If no base path is set, the
+ * deserialization will fail unless the path being deserialized is already
+ * absolute.
+ */
+export type AbsolutePathBuf = string;

package/dist/internal/codex/app-server-protocol/schema/typescript/AgentPath.d.ts

@@ -0,0 +1 @@
+export type AgentPath = string;

package/dist/internal/codex/app-server-protocol/schema/typescript/ApplyPatchApprovalParams.d.ts

@@ -0,0 +1,22 @@
+import type { FileChange } from "./FileChange.js";
+import type { ThreadId } from "./ThreadId.js";
+export type ApplyPatchApprovalParams = {
+    conversationId: ThreadId;
+    /**
+     * Use to correlate this with [codex_protocol::protocol::PatchApplyBeginEvent]
+     * and [codex_protocol::protocol::PatchApplyEndEvent].
+     */
+    callId: string;
+    fileChanges: {
+        [key in string]?: FileChange;
+    };
+    /**
+     * Optional explanatory reason (e.g. request for extra write access).
+     */
+    reason: string | null;
+    /**
+     * When set, the agent is asking the user to allow writes under this root
+     * for the remainder of the session (unclear if this is honored today).
+     */
+    grantRoot: string | null;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/ApplyPatchApprovalResponse.d.ts

@@ -0,0 +1,4 @@
+import type { ReviewDecision } from "./ReviewDecision.js";
+export type ApplyPatchApprovalResponse = {
+    decision: ReviewDecision;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/AuthMode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Authentication mode for OpenAI-backed providers.
+ */
+export type AuthMode = "apikey" | "chatgpt" | "chatgptAuthTokens" | "agentIdentity";

package/dist/internal/codex/app-server-protocol/schema/typescript/ClientInfo.d.ts

@@ -0,0 +1,5 @@
+export type ClientInfo = {
+    name: string;
+    title: string | null;
+    version: string;
+};

package/dist/internal/codex/app-server-protocol/schema/typescript/ClientNotification.d.ts

@@ -0,0 +1,3 @@
+export type ClientNotification = {
+    "method": "initialized";
+};