@jrkropp/codex-js 0.1.2 → 0.1.3

package/dist/chat-runtime-B6azJyKo.d.ts

@@ -0,0 +1,381 @@
+import * as React from 'react';
+import { ReactNode, ComponentPropsWithRef, RefObject, ReactElement, ComponentProps } from 'react';
+import { LegendListRef } from '@legendapp/list/react';
+import { l as ThreadId, C as CollaborationMode, a4 as UserMessageTurnItem, w as DynamicToolCallRequest, v as RequestPermissionsEvent, t as TurnItem } from './protocol-mpBcYHrm.js';
+import { R as RequestId } from './ToolRequestUserInputQuestion-CeZa5X1J.js';
+import { k as ThreadStartParams, n as TurnStartParams } from './ThreadResumeResponse-DvmE1juU.js';
+import { a as ServerRequest } from './ServerRequest-B5cKVJjr.js';
+import { R as Result, J as JSONRPCErrorError } from './lib-nXlaKiS-.js';
+import { e as StoredThread } from './types-BTeabLYr.js';
+import { C as CodexAppServer } from './session-BRYzi8OT.js';
+import { a as ThreadEventSnapshot } from './thread_event_store-C0zYzukG.js';
+import { a as ChatComposerSubmitPayload, X as PendingUserInput, Y as ContextWindowSnapshot, Z as MessagesTimelineProps, _ as ChatViewProps, $ as ChatComposer, C as ChatComposerHandle, a0 as ChatComposerRuntimeMode, a1 as ProviderStatus, a2 as ComposerBannerStackItem, b as ChatViewRenderComposerControls } from './ProviderStatusBanner-BlP6lzwE.js';
+import { S as Sidebar, a as SidebarProvider } from './sidebar-DMMij22z.js';
+import { T as ThreadStore } from './store-AGRxhgQ3.js';
+import { a as Turn } from './thread-history-builder-zW0zeqcS.js';
+
+type ThreadReader = Pick<ThreadStore, "loadHistory" | "readThread">;
+
+type CodexChatLifecycleBuildThreadStartParamsInput = {
+    threadId: ThreadId;
+};
+type CodexChatLifecycleThreadStartParams = ThreadStartParams & {
+    threadId?: ThreadId | string;
+};
+type CodexChatLifecycleBuildTurnStartParamsInput = {
+    clientMessageId: string;
+    imageUrls: string[];
+    interactionMode?: "default" | "plan";
+    runtimeMode?: "approval-required" | "auto-accept-edits" | "full-access";
+    sendContext: ChatComposerSubmitPayload;
+    threadId: ThreadId;
+};
+type CodexChatLifecycleTurnStartParams = TurnStartParams & {
+    collaborationMode?: CollaborationMode;
+    collaboration_mode?: CollaborationMode;
+    clientMessageId?: string;
+};
+type CodexChatLifecycleSendControls = {
+    clearComposer: () => void;
+    prepareForOptimisticAppend: () => Promise<void>;
+    restoreComposer: (sendContext: ChatComposerSubmitPayload) => void;
+};
+type CodexChatLifecycleSendOptions = {
+    interactionMode?: "default" | "plan";
+    runtimeMode?: "approval-required" | "auto-accept-edits" | "full-access";
+};
+type CodexChatLifecycleOptions = {
+    buildThreadStartParams?: (input: CodexChatLifecycleBuildThreadStartParamsInput) => CodexChatLifecycleThreadStartParams;
+    buildTurnStartParams?: (input: CodexChatLifecycleBuildTurnStartParamsInput) => CodexChatLifecycleTurnStartParams;
+    connectOnMount?: boolean;
+    initialState?: ThreadEventSnapshot | null;
+    isRecoverableConnectionError?: (error: Error) => boolean;
+    onActiveThread?: (thread: StoredThread | null) => void;
+    onRuntimeError?: (error: Error) => void;
+    onServerRequest?: (request: ServerRequest) => void;
+    onState?: (state: ThreadEventSnapshot | null) => void;
+    onSubmittedUserMessage?: (state: ThreadEventSnapshot) => void;
+    onThreadListChanged?: () => void;
+    onThreadStarted?: (state: ThreadEventSnapshot) => void;
+    appServer: CodexAppServer;
+    threadReader?: ThreadReader;
+    threadId: ThreadId | string;
+};
+declare function createDefaultTurnStartParams({ clientMessageId, imageUrls, interactionMode, runtimeMode, sendContext, threadId, }: CodexChatLifecycleBuildTurnStartParamsInput): CodexChatLifecycleTurnStartParams;
+type CodexChatLifecycle = {
+    activeThread: StoredThread | null;
+    activeWorkStartedAt: string | null;
+    assistantStreaming: boolean;
+    compact: () => Promise<boolean>;
+    connectionStatus: ThreadEventSnapshot["connectionStatus"] | "idle";
+    interrupt: () => Promise<boolean>;
+    isSendBusy: boolean;
+    isSending: boolean;
+    isWorking: boolean;
+    pendingPermissionRequestActive: boolean;
+    pendingUserInputActive: boolean;
+    reconnect: () => void;
+    runtimeError: string | null;
+    sendComposerMessage: (sendContext: ChatComposerSubmitPayload, controls: CodexChatLifecycleSendControls, options?: CodexChatLifecycleSendOptions) => Promise<void>;
+    resolveServerRequest: (requestId: RequestId, response: Result) => Promise<boolean>;
+    rejectServerRequest: (requestId: RequestId, error: JSONRPCErrorError) => Promise<boolean>;
+    threadSnapshot: ThreadEventSnapshot | null;
+    threadId: ThreadId;
+    turnRunning: boolean;
+    visibleOptimisticUserMessages: readonly UserMessageTurnItem[];
+};
+declare function useCodexChatLifecycle(options: CodexChatLifecycleOptions): CodexChatLifecycle;
+
+type CodexChatInteractionMode = "default" | "plan";
+type CodexChatProposedPlan = {
+    id: string;
+    planMarkdown: string;
+    title: string | null;
+    turnId: string;
+};
+type CodexChatPendingUserInputRequest = {
+    kind: "userInput";
+    itemId: string;
+    pendingUserInput: PendingUserInput;
+    request: Extract<ServerRequest, {
+        method: "item/tool/requestUserInput";
+    }>;
+    requestId: RequestId;
+    threadId: string;
+    turnId: string;
+};
+type CodexChatPendingPermissionRequest = {
+    kind: "permissions";
+    composerRequest: RequestPermissionsEvent;
+    request: Extract<ServerRequest, {
+        method: "item/permissions/requestApproval";
+    }>;
+    requestId: RequestId;
+    threadId: string;
+    turnId: string | null;
+};
+type CodexChatPendingDynamicToolCallRequest = {
+    kind: "dynamicToolCall";
+    compatRequest: DynamicToolCallRequest;
+    request: Extract<ServerRequest, {
+        method: "item/tool/call";
+    }>;
+    requestId: RequestId;
+    threadId: string;
+    turnId: string | null;
+};
+type CodexChatPendingMcpElicitationRequest = {
+    kind: "mcpElicitation";
+    request: Extract<ServerRequest, {
+        method: "mcpServer/elicitation/request";
+    }>;
+    requestId: RequestId;
+    threadId: string | null;
+    turnId: string | null;
+};
+type CodexChatPendingCommandApprovalRequest = {
+    kind: "commandApproval";
+    request: Extract<ServerRequest, {
+        method: "item/commandExecution/requestApproval";
+    }>;
+    requestId: RequestId;
+    threadId: string;
+    turnId: string | null;
+};
+type CodexChatPendingFileChangeApprovalRequest = {
+    kind: "fileChangeApproval";
+    request: Extract<ServerRequest, {
+        method: "item/fileChange/requestApproval";
+    }>;
+    requestId: RequestId;
+    threadId: string;
+    turnId: string | null;
+};
+type CodexChatPendingAuthRefreshRequest = {
+    kind: "chatgptAuthTokensRefresh";
+    request: Extract<ServerRequest, {
+        method: "account/chatgptAuthTokens/refresh";
+    }>;
+    requestId: RequestId;
+    threadId: null;
+    turnId: null;
+};
+type CodexChatPendingApplyPatchApprovalRequest = {
+    kind: "applyPatchApproval";
+    request: Extract<ServerRequest, {
+        method: "applyPatchApproval";
+    }>;
+    requestId: RequestId;
+    threadId: string;
+    turnId: null;
+};
+type CodexChatPendingExecCommandApprovalRequest = {
+    kind: "execCommandApproval";
+    request: Extract<ServerRequest, {
+        method: "execCommandApproval";
+    }>;
+    requestId: RequestId;
+    threadId: string;
+    turnId: null;
+};
+type CodexChatPendingRequest = CodexChatPendingApplyPatchApprovalRequest | CodexChatPendingAuthRefreshRequest | CodexChatPendingCommandApprovalRequest | CodexChatPendingDynamicToolCallRequest | CodexChatPendingExecCommandApprovalRequest | CodexChatPendingFileChangeApprovalRequest | CodexChatPendingMcpElicitationRequest | CodexChatPendingPermissionRequest | CodexChatPendingUserInputRequest;
+type CodexChatRenderLifecycleState = {
+    activeWorkStartedAt: string | null;
+    isWorking: boolean;
+    runtimeError: string | null;
+    visibleOptimisticUserMessages: readonly UserMessageTurnItem[];
+};
+type CodexChatPendingRequestRenderContext = {
+    defaultNode: ReactNode;
+    reject: (message?: string | JSONRPCErrorError) => Promise<boolean>;
+    request: CodexChatPendingRequest;
+    resolve: (result: Result) => Promise<boolean>;
+    state: CodexChatRenderState;
+};
+type CodexChatPendingUserInputRenderContext = {
+    defaultNode: ReactNode;
+    reject: (message?: string | JSONRPCErrorError) => Promise<boolean>;
+    request: CodexChatPendingUserInputRequest;
+    resolve: (result: Result) => Promise<boolean>;
+    state: CodexChatRenderState;
+};
+type CodexChatRenderStateInput = {
+    interactionMode?: CodexChatInteractionMode;
+    lifecycle?: Partial<CodexChatRenderLifecycleState>;
+    snapshot: ThreadEventSnapshot | null;
+};
+type CodexChatRenderState = {
+    activeProposedPlan: CodexChatProposedPlan | null;
+    activeTurnStartedAt: string | null;
+    banners: CodexChatRenderBanner[];
+    composer: CodexChatComposerRenderState;
+    errors: string[];
+    interactionMode: CodexChatInteractionMode;
+    items: TurnItem[];
+    isWorking: boolean;
+    optimisticUserMessages: readonly UserMessageTurnItem[];
+    pending_dynamic_tool_call_requests: DynamicToolCallRequest[];
+    pendingRequests: readonly CodexChatPendingRequest[];
+    pendingPermissionRequest: CodexChatPendingPermissionRequest | null;
+    pendingUserInputRequest: CodexChatPendingUserInputRequest | null;
+    runtimeError: string | null;
+    running_turn_ids: string[];
+    showPlanFollowUpPrompt: boolean;
+    timeline: Omit<MessagesTimelineProps, "listRef" | "onImageExpand" | "onIsAtEndChange">;
+    turns: Turn[];
+    warnings: string[];
+};
+type CodexChatComposerRenderState = {
+    contextWindow: ContextWindowSnapshot | null;
+    pendingUserInput: PendingUserInput | null;
+    pendingUserInputAdapter: CodexChatPendingUserInputRequest | null;
+};
+type CodexChatRenderBanner = {
+    description?: string;
+    id: string;
+    request?: CodexChatPendingRequest;
+    title: string;
+    tone?: "destructive";
+    variant: "error" | "info" | "success" | "warning";
+};
+declare function createCodexChatRenderState({ interactionMode, lifecycle, snapshot, }: CodexChatRenderStateInput): CodexChatRenderState;
+
+type CodexChatViewComposerProps = ComponentPropsWithRef<typeof ChatComposer>;
+type CodexChatComposerCommand = NonNullable<CodexChatViewComposerProps["composerCommands"]>[number];
+type CodexChatComposerCommandName = CodexChatComposerCommand["name"];
+type CodexChatComposerSkill = NonNullable<CodexChatViewComposerProps["composerSkills"]>[number];
+type CodexChatModelOption = NonNullable<CodexChatViewComposerProps["modelOptions"]>[number];
+type CodexChatProviderStatus = ProviderStatus;
+type CodexChatRuntimeMode = ChatComposerRuntimeMode;
+type CodexChatViewManualProps = Omit<ChatViewProps, "composer"> & {
+    composer: CodexChatViewComposerProps;
+    lifecycle?: never;
+};
+type CodexChatViewLifecycleProps = Omit<ChatViewProps, "composer" | "listRef" | "onControlsChange" | "onIsAtEndChange" | "threadKey" | "timeline" | "title"> & {
+    composerCommands?: CodexChatViewComposerProps["composerCommands"];
+    composerSkills?: CodexChatViewComposerProps["composerSkills"];
+    composerDraftKey?: string;
+    composerRef?: RefObject<ChatComposerHandle | null>;
+    editorAriaLabel?: string;
+    isEnvironmentUnavailable?: boolean;
+    defaultInteractionMode?: CodexChatInteractionMode;
+    defaultRuntimeMode?: CodexChatRuntimeMode;
+    interactionMode?: CodexChatInteractionMode;
+    listRef?: RefObject<LegendListRef | null>;
+    lifecycle: CodexChatLifecycleOptions;
+    mentionRefs?: CodexChatViewComposerProps["mentionRefs"];
+    modelOptions?: CodexChatViewComposerProps["modelOptions"];
+    placeholder?: string;
+    providerStatus?: CodexChatProviderStatus | null;
+    realtimeConversation?: CodexChatViewComposerProps["realtimeConversation"];
+    renderBannerItems?: (state: CodexChatRenderState) => readonly ComposerBannerStackItem[];
+    renderPendingRequest?: (context: CodexChatPendingRequestRenderContext) => ReactNode;
+    renderPendingUserInput?: (context: CodexChatPendingUserInputRenderContext) => ReactNode;
+    renderTimelineExtras?: (context: {
+        state: CodexChatRenderState;
+    }) => ReactNode;
+    showInteractionModeToggle?: boolean;
+    runtimeMode?: CodexChatRuntimeMode;
+    showPlanToggle?: boolean;
+    planSidebarLabel?: string;
+    planSidebarOpen?: boolean;
+    onCommand?: CodexChatViewComposerProps["onCommand"];
+    onComposerError?: (message: string | null) => void;
+    onControlsChange?: (controls: ChatViewRenderComposerControls | null) => void;
+    onIsAtEndChange?: (isAtEnd: boolean) => void;
+    onImplementProposedPlan?: (plan: CodexChatProposedPlan) => void;
+    onInteractionModeChange?: (mode: CodexChatInteractionMode) => void;
+    onRuntimeModeChange?: (mode: CodexChatRuntimeMode) => void;
+    onTogglePlanSidebar?: () => void;
+    threadKey?: string;
+    title?: ReactNode;
+};
+type CodexChatViewProps = CodexChatViewLifecycleProps | CodexChatViewManualProps;
+declare function CodexChatView(props: CodexChatViewProps): ReactElement;
+
+type CodexChatLifecyclePassthroughProps = Pick<CodexChatLifecycleOptions, "buildThreadStartParams" | "buildTurnStartParams" | "connectOnMount" | "initialState" | "isRecoverableConnectionError" | "onActiveThread" | "onRuntimeError" | "onServerRequest" | "onState" | "onSubmittedUserMessage" | "onThreadListChanged" | "onThreadStarted">;
+type CodexChatProps = Omit<CodexChatViewLifecycleProps, "lifecycle"> & CodexChatLifecyclePassthroughProps & {
+    appServer: CodexAppServer;
+    threadId: ThreadId | string;
+    threadReader?: ThreadReader;
+};
+declare function CodexChat({ appServer, buildThreadStartParams, buildTurnStartParams, connectOnMount, initialState, isRecoverableConnectionError, onActiveThread, onRuntimeError, onServerRequest, onState, onSubmittedUserMessage, onThreadListChanged, onThreadStarted, threadId, threadReader, ...viewProps }: CodexChatProps): React.FunctionComponentElement<CodexChatViewProps>;
+
+type CodexChatSidebarProps = ComponentProps<typeof Sidebar>;
+declare function CodexChatSidebar(props: CodexChatSidebarProps): React.FunctionComponentElement<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}>;
+type CodexChatLayoutProps = {
+    children: ReactNode;
+    sidebar?: ReactNode;
+    side?: CodexChatSidebarProps["side"];
+    collapsible?: CodexChatSidebarProps["collapsible"];
+    defaultOpen?: ComponentProps<typeof SidebarProvider>["defaultOpen"];
+    open?: ComponentProps<typeof SidebarProvider>["open"];
+    onOpenChange?: ComponentProps<typeof SidebarProvider>["onOpenChange"];
+    className?: ComponentProps<typeof SidebarProvider>["className"];
+};
+declare function CodexChatLayout({ children, className, collapsible, defaultOpen, onOpenChange, open, side, sidebar, }: CodexChatLayoutProps): React.FunctionComponentElement<React.FragmentProps> | React.FunctionComponentElement<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}>;
+
+type MessagePart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    url: string;
+} | {
+    type: "file";
+    name?: string;
+    url: string;
+} | {
+    type: "tool-call";
+    input: unknown;
+    name: string;
+    toolCallId: string;
+} | {
+    type: "tool-result";
+    output: unknown;
+    toolCallId: string;
+};
+type ChatMessage = {
+    id: string;
+    metadata?: Record<string, unknown>;
+    parts: MessagePart[];
+    role: "assistant" | "system" | "user";
+};
+type ChatRuntimeStatus = "error" | "idle" | "loading" | "ready" | "streaming" | "submitting";
+type SendMessageInput = {
+    files?: FileList | File[] | MessagePart[];
+    metadata?: Record<string, unknown>;
+    text?: string;
+};
+type ChatRuntime = {
+    error: Error | null;
+    messages: ChatMessage[];
+    sendMessage(input: SendMessageInput): Promise<void>;
+    setThread(threadId: ThreadId | string | null): void;
+    status: ChatRuntimeStatus;
+    stop(): Promise<void>;
+    threadId: ThreadId | string | null;
+    threadSnapshot: ThreadEventSnapshot | null;
+    threadState: CodexChatRenderState | null;
+};
+type CodexChatRuntimeOptions = {
+    appServer: CodexAppServer;
+    threadReader?: ThreadReader;
+    threadId?: ThreadId | string;
+};
+type CodexChatProviderProps = CodexChatRuntimeOptions & {
+    children?: ReactNode;
+};
+declare function CodexChatProvider({ appServer, children, threadReader, threadId, }: CodexChatProviderProps): React.FunctionComponentElement<React.ProviderProps<ChatRuntime | null>>;
+declare function useCodexChatRuntime(): ChatRuntime;
+declare function useCodexChat(options: CodexChatRuntimeOptions): ChatRuntime;
+
+export { type CodexChatRuntimeOptions as A, type CodexChatViewComposerProps as B, CodexChat as C, type CodexChatViewLifecycleProps as D, type CodexChatViewManualProps as E, createCodexChatRenderState as F, createDefaultTurnStartParams as G, useCodexChat as H, useCodexChatLifecycle as I, useCodexChatRuntime as J, type MessagePart as M, type SendMessageInput as S, type ThreadReader as T, CodexChatLayout as a, type CodexChatLayoutProps as b, type CodexChatProps as c, CodexChatProvider as d, type CodexChatProviderProps as e, CodexChatSidebar as f, type CodexChatSidebarProps as g, CodexChatView as h, type CodexChatViewProps as i, type ChatMessage as j, type ChatRuntime as k, type ChatRuntimeStatus as l, type CodexChatComposerCommand as m, type CodexChatComposerCommandName as n, type CodexChatComposerSkill as o, type CodexChatInteractionMode as p, type CodexChatLifecycle as q, type CodexChatLifecycleOptions as r, type CodexChatModelOption as s, type CodexChatPendingRequest as t, type CodexChatPendingRequestRenderContext as u, type CodexChatPendingUserInputRenderContext as v, type CodexChatProposedPlan as w, type CodexChatProviderStatus as x, type CodexChatRenderState as y, type CodexChatRuntimeMode as z };