@jrkropp/codex-js-react 0.2.0

package/dist/hooks/chat-lifecycle.d.ts

@@ -0,0 +1,73 @@
+import { type CollaborationMode, type CoreUserMessageTurnItem as UserMessageTurnItem, type JSONRPCErrorError, type Result, type RequestId, type ServerRequest, type StoredThread, type ThreadEventSnapshot, type ThreadId, type ThreadStartParams, type TurnStartParams } from "@jrkropp/codex-js/client";
+import type { CodexAppServer, ThreadReader } from "./thread-reader.js";
+import { type ChatComposerSubmitPayload } from "../internal/chat-ui/index.js";
+export type CodexChatLifecycleBuildThreadStartParamsInput = {
+    threadId: ThreadId;
+};
+export type CodexChatLifecycleThreadStartParams = ThreadStartParams & {
+    threadId?: ThreadId | string;
+};
+export type CodexChatLifecycleBuildTurnStartParamsInput = {
+    clientMessageId: string;
+    imageUrls: string[];
+    interactionMode?: "default" | "plan";
+    runtimeMode?: "approval-required" | "auto-accept-edits" | "full-access";
+    sendContext: ChatComposerSubmitPayload;
+    threadId: ThreadId;
+};
+export type CodexChatLifecycleTurnStartParams = TurnStartParams & {
+    collaborationMode?: CollaborationMode;
+    collaboration_mode?: CollaborationMode;
+    clientMessageId?: string;
+};
+export type CodexChatLifecycleSendControls = {
+    clearComposer: () => void;
+    prepareForOptimisticAppend: () => Promise<void>;
+    restoreComposer: (sendContext: ChatComposerSubmitPayload) => void;
+};
+export type CodexChatLifecycleSendOptions = {
+    interactionMode?: "default" | "plan";
+    runtimeMode?: "approval-required" | "auto-accept-edits" | "full-access";
+};
+export 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;
+};
+export declare function createDefaultThreadStartParams({ threadId, }: CodexChatLifecycleBuildThreadStartParamsInput): CodexChatLifecycleThreadStartParams;
+export declare function createDefaultTurnStartParams({ clientMessageId, imageUrls, interactionMode, runtimeMode, sendContext, threadId, }: CodexChatLifecycleBuildTurnStartParamsInput): CodexChatLifecycleTurnStartParams;
+export 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[];
+};
+export declare function useCodexChatLifecycle(options: CodexChatLifecycleOptions): CodexChatLifecycle;

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export type { CodexAppServer, ThreadId, ThreadReader, } from "./thread-reader.js";
+export { createLocalDispatchSnapshot, deriveActiveWorkStartedAt, deriveAssistantStreaming, deriveChatLifecycleWorkingState, hasServerAcknowledgedLocalDispatch, threadHasStarted, useLocalDispatchState, } from "./lifecycle.js";
+export type { LocalDispatchSnapshot } from "./lifecycle.js";
+export { createDefaultThreadStartParams, createDefaultTurnStartParams, useCodexChatLifecycle, } from "./chat-lifecycle.js";
+export type { CodexChatLifecycle, CodexChatLifecycleBuildThreadStartParamsInput, CodexChatLifecycleBuildTurnStartParamsInput, CodexChatLifecycleOptions, CodexChatLifecycleSendControls, CodexChatLifecycleSendOptions, } from "./chat-lifecycle.js";

package/dist/hooks/lifecycle.d.ts

@@ -0,0 +1,41 @@
+import type { ThreadEventSnapshot } from "@jrkropp/codex-js/client";
+type ChatLifecycleThreadState = Pick<ThreadEventSnapshot, "activeTurnIds" | "errors" | "pendingRequests" | "turns">;
+type ChatLifecycleConnectionStatus = ThreadEventSnapshot["connectionStatus"];
+export type LocalDispatchSnapshot = {
+    errorCount: number;
+    itemIds: readonly string[];
+    runningTurnIds: readonly string[];
+    startedAt: string;
+};
+export declare function createLocalDispatchSnapshot(threadState: ChatLifecycleThreadState | null): LocalDispatchSnapshot;
+export declare function hasServerAcknowledgedLocalDispatch(input: {
+    hasPendingRequest: boolean;
+    localDispatch: LocalDispatchSnapshot | null;
+    runtimeError: string | null;
+    threadState: ChatLifecycleThreadState | null;
+}): boolean;
+export declare function useLocalDispatchState(input: {
+    hasPendingRequest: boolean;
+    runtimeError: string | null;
+    threadState: ChatLifecycleThreadState | null;
+}): {
+    beginLocalDispatch: () => void;
+    isSendBusy: boolean;
+    localDispatch: LocalDispatchSnapshot | null;
+    localDispatchStartedAt: string | null;
+    resetLocalDispatch: () => void;
+    serverAcknowledgedLocalDispatch: boolean;
+};
+export declare function deriveActiveWorkStartedAt(input: {
+    isWorking: boolean;
+    runtimeStartedAt: string | null;
+    sendStartedAt: string | null;
+}): string | null;
+export declare function deriveAssistantStreaming(threadState: ChatLifecycleThreadState | null): boolean;
+export declare function deriveChatLifecycleWorkingState(input: {
+    connectionStatus: ChatLifecycleConnectionStatus;
+    isSendBusy: boolean;
+    threadState: ChatLifecycleThreadState | null;
+}): boolean;
+export declare function threadHasStarted(threadState: ChatLifecycleThreadState | null): boolean;
+export {};

package/dist/hooks/thread-reader.d.ts

@@ -0,0 +1,3 @@
+import type { CodexAppServer, ThreadId, ThreadStore } from "@jrkropp/codex-js/client";
+export type ThreadReader = Pick<ThreadStore, "loadHistory" | "readThread">;
+export type { CodexAppServer, ThreadId };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./components/index.js";
+export { createDefaultThreadStartParams, createDefaultTurnStartParams, createLocalDispatchSnapshot, deriveActiveWorkStartedAt, deriveAssistantStreaming, deriveChatLifecycleWorkingState, hasServerAcknowledgedLocalDispatch, threadHasStarted, useCodexChatLifecycle, useLocalDispatchState, type CodexChatLifecycle, type CodexChatLifecycleBuildThreadStartParamsInput, type CodexChatLifecycleBuildTurnStartParamsInput, type CodexChatLifecycleOptions, type CodexChatLifecycleSendControls, type CodexChatLifecycleSendOptions, type LocalDispatchSnapshot, type ThreadReader, } from "./hooks/index.js";