@jrkropp/codex-js 0.1.2 → 0.1.4

package/dist/react/index.d.ts

@@ -1,61 +1,69 @@
-import { M as MentionBinding } from '../chat-runtime-D7wu_KbX.js';
-export { j as ChatComposerHandle, k as ChatComposerSubmitPayload, l as ChatMessage, m as ChatRuntime, n as ChatRuntimeStatus, C as CodexChat, o as CodexChatComposerCommand, p as CodexChatComposerCommandName, q as CodexChatComposerSkill, r as CodexChatInteractionMode, a as CodexChatLayout, b as CodexChatLayoutProps, s as CodexChatLifecycle, t as CodexChatLifecycleOptions, u as CodexChatModelOption, v as CodexChatPendingRequest, w as CodexChatPendingRequestRenderContext, x as CodexChatPendingUserInputRenderContext, y as CodexChatProposedPlan, c as CodexChatProps, d as CodexChatProvider, e as CodexChatProviderProps, z as CodexChatProviderStatus, A as CodexChatRenderState, B as CodexChatRuntimeMode, D as CodexChatRuntimeOptions, f as CodexChatSidebar, g as CodexChatSidebarProps, h as CodexChatView, E as CodexChatViewComposerProps, F as CodexChatViewLifecycleProps, G as CodexChatViewManualProps, i as CodexChatViewProps, H as CodexChatViewRenderComposerControls, I as CodexModelOption, J as CodexReasoningEffort, K as CodexReasoningEffortOption, L as ComposerDraftKey, N as ComposerDraftState, O as ComposerImageAttachment, P as ComposerImageValidationResult, Q as ExpandedImagePreview, R as MentionBindingRange, S as MessagePart, T as PersistedComposerDraftImageAttachment, U as ProviderDriverKind, V as ProviderInstanceEntry, W as ProviderInstanceId, X as RealtimeConversationControlState, Y as RealtimeConversationPhase, Z as RealtimeConversationUiState, _ as RecordingMeterState, $ as SendMessageInput, a0 as ThreadReader, a1 as WORKSPACE_CHAT_MAX_IMAGE_ATTACHMENTS, a2 as WORKSPACE_CHAT_MAX_IMAGE_BYTES, a3 as assistantComposerDraftKey, a4 as buildExpandedImagePreview, a5 as codexModelOptions, a6 as codexReasoningEffortOptions, a7 as createCodexChatRenderState, a8 as createComposerImageAttachments, a9 as createDefaultTurnStartParams, aa as defaultCodexModel, ab as defaultCodexProviderInstance, ac as defaultCodexReasoningEffort, ad as getRealtimeConversationControlState, ae as isAcceptedComposerImageFile, af as isCodexReasoningEffort, ag as isRealtimeConversationLive, ah as mentionBindingRangesForText, ai as mentionBindingsAfterReplacement, aj as normalizeMentionBindingsForText, ak as persistComposerDraftAttachments, al as resolveCodexModelOption, am as resolveCodexReasoningEffortForModel, an as resolveCodexReasoningEffortOption, ao as resolveDraftEffort, ap as resolveDraftModel, aq as restoreComposerDraftAttachments, ar as revokeComposerImageAttachments, as as useCodexChat, at as useCodexChatLifecycle, au as useCodexChatRuntime, av as useComposerDraftStore, aw as useComposerThreadDraft, ax as validateComposerImageFiles } from '../chat-runtime-D7wu_KbX.js';
+export { j as ChatMessage, k as ChatRuntime, l as ChatRuntimeStatus, C as CodexChat, m as CodexChatComposerCommand, n as CodexChatComposerCommandName, o as CodexChatComposerSkill, p as CodexChatInteractionMode, a as CodexChatLayout, b as CodexChatLayoutProps, q as CodexChatLifecycle, r as CodexChatLifecycleBuildThreadStartParamsInput, s as CodexChatLifecycleBuildTurnStartParamsInput, t as CodexChatLifecycleOptions, u as CodexChatLifecycleSendControls, v as CodexChatLifecycleSendOptions, w as CodexChatModelOption, x as CodexChatPendingRequest, y as CodexChatPendingRequestRenderContext, z as CodexChatPendingUserInputRenderContext, A as CodexChatProposedPlan, c as CodexChatProps, d as CodexChatProvider, e as CodexChatProviderProps, B as CodexChatProviderStatus, D as CodexChatRenderState, E as CodexChatRuntimeMode, F as CodexChatRuntimeOptions, f as CodexChatSidebar, g as CodexChatSidebarProps, h as CodexChatView, G as CodexChatViewComposerProps, H as CodexChatViewLifecycleProps, I as CodexChatViewManualProps, i as CodexChatViewProps, M as MessagePart, S as SendMessageInput, T as ThreadReader, J as createCodexChatRenderState, K as createDefaultThreadStartParams, L as createDefaultTurnStartParams, N as useCodexChat, O as useCodexChatLifecycle, P as useCodexChatRuntime } from '../chat-runtime-9RkXHC_w.js';
 import * as React from 'react';
 import { ReactNode } from 'react';
-import { i as TextElement } from '../thread_event_store-B9CoQUIA.js';
+export { L as LinkedMention, a as LinkedMentionRange, P as PROJECT_MENTION_SIGIL, S as SKILL_MENTION_SIGIL, T as TOOL_MENTION_SIGIL, b as buildCollapsedProposedPlanPreviewMarkdown, c as buildPlanImplementationPrompt, d as buildPlanImplementationThreadTitle, e as buildProposedPlanMarkdownFilename, f as decodeHistoryMentions, g as encodeHistoryMentions, h as findLinkedMentions, l as linkedMentionTextElements, m as mentionToken, n as normalizePlanMarkdownForExport, p as proposedPlanTitle, r as resolvePlanFollowUpSubmission, s as skillToken, i as stripDisplayedPlanMarkdown } from '../proposed-plan-DpN1ma0Y.js';
+export { C as ChatComposerHandle, a as ChatComposerSubmitPayload, b as CodexChatViewRenderComposerControls, c as CodexModelOption, d as CodexReasoningEffort, e as CodexReasoningEffortOption, f as ComposerDraftKey, g as ComposerDraftState, h as ComposerImageAttachment, i as ComposerImageValidationResult, E as ExpandedImagePreview, M as MentionBinding, j as MentionBindingRange, P as PersistedComposerDraftImageAttachment, k as ProviderDriverKind, l as ProviderInstanceEntry, m as ProviderInstanceId, R as RealtimeConversationControlState, n as RealtimeConversationPhase, o as RealtimeConversationUiState, p as RecordingMeterState, W as WORKSPACE_CHAT_MAX_IMAGE_ATTACHMENTS, q as WORKSPACE_CHAT_MAX_IMAGE_BYTES, r as assistantComposerDraftKey, s as buildExpandedImagePreview, t as codexModelOptions, u as codexReasoningEffortOptions, v as createComposerImageAttachments, w as defaultCodexModel, x as defaultCodexProviderInstance, y as defaultCodexReasoningEffort, z as getRealtimeConversationControlState, A as isAcceptedComposerImageFile, B as isCodexReasoningEffort, D as isRealtimeConversationLive, F as mentionBindingRangesForText, G as mentionBindingsAfterReplacement, H as normalizeMentionBindingsForText, I as persistComposerDraftAttachments, J as resolveCodexModelOption, K as resolveCodexReasoningEffortForModel, L as resolveCodexReasoningEffortOption, N as resolveDraftEffort, O as resolveDraftModel, Q as restoreComposerDraftAttachments, S as revokeComposerImageAttachments, T as useComposerDraftStore, U as useComposerThreadDraft, V as validateComposerImageFiles } from '../ProviderStatusBanner-BlP6lzwE.js';
+import { a as ThreadEventSnapshot } from '../thread_event_store-C0zYzukG.js';
 import '@legendapp/list/react';
-import '../session-DPhHN7RZ.js';
-import 'zustand/middleware';
-import 'zustand';
-import '../sidebar-DT2XoitN.js';
+import '../protocol-mpBcYHrm.js';
+import '../ToolRequestUserInputQuestion-CeZa5X1J.js';
+import '../ThreadResumeResponse-DvmE1juU.js';
+import '../ServerRequest-B5cKVJjr.js';
+import '../lib-nXlaKiS-.js';
+import '../types-BTeabLYr.js';
+import '../session-BRYzi8OT.js';
+import '../TurnSteerResponse-0kBCfplh.js';
+import '../sidebar-DMMij22z.js';
 import 'class-variance-authority/types';
 import 'react/jsx-runtime';
 import 'class-variance-authority';
 import 'radix-ui';
-import '../store-GYldc9EJ.js';
+import '../store-AGRxhgQ3.js';
+import '../thread-history-builder-zW0zeqcS.js';
+import '../ToolRequestUserInputResponse-zcPLwbiK.js';
+import 'zustand/middleware';
+import 'zustand';
+import '../rendered-thread-AOxw3V5b.js';
 
-type LinkedMention = {
-    mention: string;
-    path: string;
+type ChatLifecycleThreadState = Pick<ThreadEventSnapshot, "activeTurnIds" | "errors" | "pendingRequests" | "turns">;
+type ChatLifecycleConnectionStatus = ThreadEventSnapshot["connectionStatus"];
+type LocalDispatchSnapshot = {
+    errorCount: number;
+    itemIds: readonly string[];
+    runningTurnIds: readonly string[];
+    startedAt: string;
 };
-type DecodedHistoryText = {
-    mentions: LinkedMention[];
-    text: string;
-};
-type LinkedMentionRange = {
-    end: number;
-    mention: string;
-    path: string;
-    placeholder: string;
-    start: number;
-};
-declare function encodeHistoryMentions(text: string, bindings: readonly MentionBinding[]): string;
-declare function decodeHistoryMentions(text: string): DecodedHistoryText;
-declare function findLinkedMentions(text: string): LinkedMentionRange[];
-declare function linkedMentionTextElements(text: string): TextElement[];
-
-declare const PROJECT_MENTION_SIGIL = "@";
-declare const SKILL_MENTION_SIGIL = "$";
-declare const TOOL_MENTION_SIGIL = "@";
-declare function mentionToken(name: string): string;
-declare function skillToken(name: string): string;
-
-declare function proposedPlanTitle(planMarkdown: string): string | null;
-declare function stripDisplayedPlanMarkdown(planMarkdown: string): string;
-declare function buildCollapsedProposedPlanPreviewMarkdown(planMarkdown: string, options?: {
-    maxLines?: number;
-}): string;
-declare function buildPlanImplementationPrompt(planMarkdown: string): string;
-declare function resolvePlanFollowUpSubmission(input: {
-    draftText: string;
-    planMarkdown: string;
+declare function createLocalDispatchSnapshot(threadState: ChatLifecycleThreadState | null): LocalDispatchSnapshot;
+declare function hasServerAcknowledgedLocalDispatch(input: {
+    hasPendingRequest: boolean;
+    localDispatch: LocalDispatchSnapshot | null;
+    runtimeError: string | null;
+    threadState: ChatLifecycleThreadState | null;
+}): boolean;
+declare function useLocalDispatchState(input: {
+    hasPendingRequest: boolean;
+    runtimeError: string | null;
+    threadState: ChatLifecycleThreadState | null;
 }): {
-    interactionMode: "default" | "plan";
-    text: string;
+    beginLocalDispatch: () => void;
+    isSendBusy: boolean;
+    localDispatch: LocalDispatchSnapshot | null;
+    localDispatchStartedAt: string | null;
+    resetLocalDispatch: () => void;
+    serverAcknowledgedLocalDispatch: boolean;
 };
-declare function buildPlanImplementationThreadTitle(planMarkdown: string): string;
-declare function buildProposedPlanMarkdownFilename(planMarkdown: string): string;
-declare function normalizePlanMarkdownForExport(planMarkdown: string): string;
+declare function deriveActiveWorkStartedAt(input: {
+    isWorking: boolean;
+    runtimeStartedAt: string | null;
+    sendStartedAt: string | null;
+}): string | null;
+declare function deriveAssistantStreaming(threadState: ChatLifecycleThreadState | null): boolean;
+declare function deriveChatLifecycleWorkingState(input: {
+    connectionStatus: ChatLifecycleConnectionStatus;
+    isSendBusy: boolean;
+    threadState: ChatLifecycleThreadState | null;
+}): boolean;
+declare function threadHasStarted(threadState: ChatLifecycleThreadState | null): boolean;
 
 declare function CodexThread({ children }: {
     children?: ReactNode;
@@ -70,4 +78,4 @@ declare function CodexComposer(): React.ReactElement<{
     "data-codex-composer": string;
 }, string | React.JSXElementConstructor<any>>;
 
-export { CodexComposer, CodexMessages, CodexThread, type LinkedMention, type LinkedMentionRange, MentionBinding, PROJECT_MENTION_SIGIL, SKILL_MENTION_SIGIL, TOOL_MENTION_SIGIL, buildCollapsedProposedPlanPreviewMarkdown, buildPlanImplementationPrompt, buildPlanImplementationThreadTitle, buildProposedPlanMarkdownFilename, decodeHistoryMentions, encodeHistoryMentions, findLinkedMentions, linkedMentionTextElements, mentionToken, normalizePlanMarkdownForExport, proposedPlanTitle, resolvePlanFollowUpSubmission, skillToken, stripDisplayedPlanMarkdown };
+export { CodexComposer, CodexMessages, CodexThread, type LocalDispatchSnapshot, createLocalDispatchSnapshot, deriveActiveWorkStartedAt, deriveAssistantStreaming, deriveChatLifecycleWorkingState, hasServerAcknowledgedLocalDispatch, threadHasStarted, useLocalDispatchState };

package/dist/react/index.js

@@ -1,5 +1,19 @@
-export { CodexChat, CodexChatLayout, CodexChatProvider, CodexChatSidebar, CodexChatView, CodexComposer, CodexMessages, CodexThread, PROJECT_MENTION_SIGIL, RecordingMeterState, SKILL_MENTION_SIGIL, TOOL_MENTION_SIGIL, WORKSPACE_CHAT_MAX_IMAGE_ATTACHMENTS, WORKSPACE_CHAT_MAX_IMAGE_BYTES, assistantComposerDraftKey, buildCollapsedProposedPlanPreviewMarkdown, buildExpandedImagePreview, buildPlanImplementationPrompt, buildPlanImplementationThreadTitle, buildProposedPlanMarkdownFilename, codexModelOptions, codexReasoningEffortOptions, createCodexChatRenderState, createComposerImageAttachments, createDefaultTurnStartParams, decodeHistoryMentions, defaultCodexModel, defaultCodexProviderInstance, defaultCodexReasoningEffort, encodeHistoryMentions, findLinkedMentions, getRealtimeConversationControlState, isAcceptedComposerImageFile, isCodexReasoningEffort, isRealtimeConversationLive, linkedMentionTextElements, mentionBindingRangesForText, mentionBindingsAfterReplacement, mentionToken, normalizeMentionBindingsForText, normalizePlanMarkdownForExport, persistComposerDraftAttachments, proposedPlanTitle, resolveCodexModelOption, resolveCodexReasoningEffortForModel, resolveCodexReasoningEffortOption, resolveDraftEffort, resolveDraftModel, resolvePlanFollowUpSubmission, restoreComposerDraftAttachments, revokeComposerImageAttachments, skillToken, stripDisplayedPlanMarkdown, useCodexChat, useCodexChatLifecycle, useCodexChatRuntime, useComposerDraftStore, useComposerThreadDraft, validateComposerImageFiles } from '../chunk-JLDH4U5L.js';
+export { CodexChat, CodexChatLayout, CodexChatProvider, CodexChatSidebar, CodexChatView, CodexComposer, CodexMessages, CodexThread, createCodexChatRenderState, createDefaultThreadStartParams, createDefaultTurnStartParams, createLocalDispatchSnapshot, deriveActiveWorkStartedAt, deriveAssistantStreaming, deriveChatLifecycleWorkingState, hasServerAcknowledgedLocalDispatch, threadHasStarted, useCodexChat, useCodexChatLifecycle, useCodexChatRuntime, useLocalDispatchState } from '../chunk-W7S6HFCQ.js';
+import '../chunk-5JMJ6OI5.js';
+export { PROJECT_MENTION_SIGIL, RecordingMeterState, SKILL_MENTION_SIGIL, TOOL_MENTION_SIGIL, WORKSPACE_CHAT_MAX_IMAGE_ATTACHMENTS, WORKSPACE_CHAT_MAX_IMAGE_BYTES, assistantComposerDraftKey, buildCollapsedProposedPlanPreviewMarkdown, buildExpandedImagePreview, buildPlanImplementationPrompt, buildPlanImplementationThreadTitle, buildProposedPlanMarkdownFilename, codexModelOptions, codexReasoningEffortOptions, createComposerImageAttachments, decodeHistoryMentions, defaultCodexModel, defaultCodexProviderInstance, defaultCodexReasoningEffort, encodeHistoryMentions, findLinkedMentions, getRealtimeConversationControlState, isAcceptedComposerImageFile, isCodexReasoningEffort, isRealtimeConversationLive, linkedMentionTextElements, mentionBindingRangesForText, mentionBindingsAfterReplacement, mentionToken, normalizeMentionBindingsForText, normalizePlanMarkdownForExport, persistComposerDraftAttachments, proposedPlanTitle, resolveCodexModelOption, resolveCodexReasoningEffortForModel, resolveCodexReasoningEffortOption, resolveDraftEffort, resolveDraftModel, resolvePlanFollowUpSubmission, restoreComposerDraftAttachments, revokeComposerImageAttachments, skillToken, stripDisplayedPlanMarkdown, useComposerDraftStore, useComposerThreadDraft, validateComposerImageFiles } from '../chunk-NCI4MAWZ.js';
 import '../chunk-FN3SWHRH.js';
-import '../chunk-SVK6PLGO.js';
+import '../chunk-6ZMJ34KE.js';
+import '../chunk-4DPLJPB5.js';
+import '../chunk-V4BMZWBM.js';
+import '../chunk-LWQNX4LI.js';
+import '../chunk-PST3ZWX2.js';
+import '../chunk-Z63UPBS3.js';
+import '../chunk-YHVCFD2D.js';
+import '../chunk-DCMKA2A6.js';
+import '../chunk-CGBS37IU.js';
+import '../chunk-2DZRMCI2.js';
+import '../chunk-DYLHN3HG.js';
+import '../chunk-SYPHCDRD.js';
+import '../chunk-O44XP7LH.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/{remote-_6TDvg-g.d.ts → remote-ClZbq9KN.d.ts}

@@ -1,4 +1,6 @@
-import { I as InitializeParams, A as AppServerEvent, C as CodexAppServer } from './session-DPhHN7RZ.js';
+import { I as InitializeParams } from './ThreadResumeResponse-DvmE1juU.js';
+import { A as AppServerEvent } from './lib-nXlaKiS-.js';
+import { C as CodexAppServer } from './session-BRYzi8OT.js';
 
 type CodexAppServerClientConnectionStatus = "connecting" | "connected" | "closed" | "error";
 type CodexAppServerClientOptions = {

package/dist/rendered-thread-AOxw3V5b.d.ts

@@ -0,0 +1,29 @@
+import { l as ThreadId, t as TurnItem, u as RequestUserInputEvent, v as RequestPermissionsEvent, w as DynamicToolCallRequest, E as EventMsg, j as RolloutItem } from './protocol-mpBcYHrm.js';
+import { f as StoredThreadHistory } from './types-BTeabLYr.js';
+import { a as Turn } from './thread-history-builder-zW0zeqcS.js';
+
+type RenderedThreadConnectionStatus = "idle" | "connecting" | "connected" | "reconnecting" | "closed" | "error";
+type RenderedThreadState = {
+    thread_id: ThreadId;
+    turns: Turn[];
+    items: TurnItem[];
+    pending_request_user_input: RequestUserInputEvent | null;
+    pending_request_permissions: RequestPermissionsEvent | null;
+    pending_dynamic_tool_call_requests: DynamicToolCallRequest[];
+    running_turn_ids: string[];
+    warnings: string[];
+    errors: string[];
+    last_history_fingerprint: string | null;
+    connection_status: RenderedThreadConnectionStatus;
+};
+type ApplyEventOptions = {
+    event_id?: string;
+};
+declare function createRenderedThreadState(threadId: ThreadId): RenderedThreadState;
+declare function renderThreadFromHistory(history: StoredThreadHistory): RenderedThreadState;
+declare function applyRolloutItemToRenderedThread(state: RenderedThreadState, item: RolloutItem, index?: number): RenderedThreadState;
+declare function applyEventMsgToRenderedThread(state: RenderedThreadState, msg: EventMsg, options?: ApplyEventOptions): RenderedThreadState;
+declare function setRenderedThreadConnectionStatus(state: RenderedThreadState, connectionStatus: RenderedThreadConnectionStatus): RenderedThreadState;
+declare function fingerprintRolloutItems(items: readonly RolloutItem[]): string;
+
+export { type ApplyEventOptions as A, type RenderedThreadConnectionStatus as R, type RenderedThreadState as a, applyEventMsgToRenderedThread as b, createRenderedThreadState as c, applyRolloutItemToRenderedThread as d, fingerprintRolloutItems as f, renderThreadFromHistory as r, setRenderedThreadConnectionStatus as s };

package/dist/responses_websocket-BhxSgCzK.d.ts

@@ -0,0 +1,183 @@
+import { A as ResponseItem, G as ToolSpec, B as BaseInstructions, H as TokenUsage, I as RateLimitSnapshot, J as SessionSource } from './protocol-mpBcYHrm.js';
+import { k as ProviderRuntimeConfig } from './index-CoDZosq0.js';
+
+declare const WS_REQUEST_HEADER_TRACEPARENT_CLIENT_METADATA_KEY = "ws_request_header_traceparent";
+declare const WS_REQUEST_HEADER_TRACESTATE_CLIENT_METADATA_KEY = "ws_request_header_tracestate";
+type Prompt = {
+    input: ResponseItem[];
+    tools: ToolSpec[];
+    parallel_tool_calls: boolean;
+    base_instructions: BaseInstructions;
+};
+type ResponseEvent = {
+    type: "created";
+} | {
+    type: "output_text_delta";
+    item_id?: string;
+    delta: string;
+} | {
+    type: "tool_call_input_delta";
+    item_id: string;
+    call_id?: string | null;
+    delta: string;
+} | {
+    type: "reasoning_summary_delta";
+    delta: string;
+    summary_index: number;
+} | {
+    type: "reasoning_content_delta";
+    delta: string;
+    content_index: number;
+} | {
+    type: "reasoning_summary_part_added";
+    summary_index: number;
+} | {
+    type: "output_item_added";
+    item: ResponseItem;
+} | {
+    type: "output_item_done";
+    item: ResponseItem;
+} | {
+    type: "server_model";
+    model: string;
+} | {
+    type: "model_verifications";
+    model_verifications: unknown[];
+} | {
+    type: "server_reasoning_included";
+    reasoning_included: boolean;
+} | {
+    type: "completed";
+    response_id: string;
+    token_usage?: TokenUsage | null;
+    end_turn?: boolean | null;
+} | {
+    type: "rate_limits";
+    rate_limits: RateLimitSnapshot;
+} | {
+    type: "models_etag";
+    etag: string;
+};
+type ResponseStream = AsyncIterable<ResponseEvent> & {
+    upstream_request_id?: string | null;
+};
+type TurnState = {
+    get(): string | null;
+    set(value: string): void;
+};
+type ResponsesApiRequest = {
+    model: string;
+    instructions: string;
+    input: ResponseItem[];
+    tools: unknown[];
+    tool_choice: string;
+    parallel_tool_calls: boolean;
+    reasoning: unknown | null;
+    store: boolean;
+    stream: true;
+    include: string[];
+    service_tier?: string;
+    prompt_cache_key?: string;
+    text?: unknown;
+    client_metadata?: Record<string, string>;
+};
+type ResponseCreateWsRequest = Omit<ResponsesApiRequest, "stream"> & {
+    stream: true;
+    previous_response_id?: string;
+    generate?: boolean;
+};
+type ResponseProcessedWsRequest = {
+    response_id: string;
+};
+type ResponsesWsRequest = ({
+    type: "response.create";
+} & ResponseCreateWsRequest) | ({
+    type: "response.processed";
+} & ResponseProcessedWsRequest);
+type W3cTraceContext = {
+    traceparent?: string | null;
+    tracestate?: string | null;
+};
+declare function responseCreateWsRequestFromResponsesApiRequest(request: ResponsesApiRequest): ResponseCreateWsRequest;
+declare function response_create_client_metadata(client_metadata: Record<string, string> | null | undefined, trace?: W3cTraceContext | null): Record<string, string> | undefined;
+
+type Compression = "none" | "zstd";
+type ResponsesOptions = {
+    signal?: AbortSignal;
+    thread_id?: string | null;
+    session_id?: string | null;
+    session_source?: SessionSource | string | null;
+    extra_headers?: HeadersInit;
+    compression?: Compression;
+    turn_state?: TurnState | null;
+};
+type ResponsesClientInput = {
+    api_key: string;
+    runtime: ProviderRuntimeConfig;
+    originator: string;
+    user_agent: string;
+    chatgpt_account_id?: string | null;
+    fedramp?: boolean;
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+};
+declare class ResponsesClient {
+    private readonly input;
+    private readonly fetcher;
+    constructor(input: ResponsesClientInput);
+    stream_request(request: ResponsesApiRequest, options?: ResponsesOptions): Promise<ResponseStream>;
+    streamRequest(request: ResponsesApiRequest, options?: ResponsesOptions): Promise<ResponseStream>;
+}
+
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+type WorkerWebSocket = WebSocket & {
+    accept?: (options?: unknown) => void;
+    binaryType?: BinaryType;
+};
+type ResponsesWebsocketClientInput = {
+    api_key: string;
+    runtime: ProviderRuntimeConfig;
+    originator: string;
+    user_agent: string;
+    chatgpt_account_id?: string | null;
+    fedramp?: boolean;
+    fetch?: FetchLike;
+};
+declare class WsStream {
+    private readonly socket;
+    private readonly queued;
+    private readonly waiters;
+    private closed;
+    constructor(socket: WorkerWebSocket);
+    is_closed(): boolean;
+    send(message: string): void;
+    close(): void;
+    next(timeoutMs?: number | null): Promise<MessageEvent | CloseEvent | ErrorEvent>;
+    private push;
+}
+declare class ResponsesWebsocketConnection {
+    private readonly input;
+    private lock;
+    private streamClosed;
+    constructor(input: {
+        stream: WsStream;
+        idle_timeout_ms?: number | null;
+        server_reasoning_included?: boolean;
+        models_etag?: string | null;
+        server_model?: string | null;
+    });
+    is_closed(): Promise<boolean>;
+    send_response_processed(response_id: string): Promise<void>;
+    stream_request(request: ResponsesWsRequest, connection_reused: boolean): Promise<ResponseStream>;
+    close(): void;
+    private initialEvents;
+    private runWebsocketResponseStream;
+    private withExclusiveStream;
+}
+declare class ResponsesWebsocketClient {
+    private readonly input;
+    private readonly fetcher;
+    constructor(input: ResponsesWebsocketClientInput);
+    connect(extra_headers?: HeadersInit, default_headers?: HeadersInit, turn_state?: TurnState | null): Promise<ResponsesWebsocketConnection>;
+}
+
+export { type Compression as C, type Prompt as P, type ResponseCreateWsRequest as R, type TurnState as T, type W3cTraceContext as W, type ResponseEvent as a, type ResponseProcessedWsRequest as b, type ResponseStream as c, type ResponsesApiRequest as d, ResponsesClient as e, type ResponsesClientInput as f, ResponsesWebsocketClient as g, ResponsesWebsocketConnection as h, type ResponsesWsRequest as i, type ResponsesOptions as j, type ResponsesWebsocketClientInput as k, WS_REQUEST_HEADER_TRACEPARENT_CLIENT_METADATA_KEY as l, WS_REQUEST_HEADER_TRACESTATE_CLIENT_METADATA_KEY as m, WsStream as n, response_create_client_metadata as o, responseCreateWsRequestFromResponsesApiRequest as r };