@jrkropp/codex-js 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @jrkropp/codex-js
 
+## 0.1.3
+
+Expose deliberate low-level Codex and T3 mirror subpaths so host adapters can migrate off the vendored workspace package.
+
+## 0.1.2
+
+Expose the complete Codex runtime surface from the public server subpath for host adapters.
+
 ## 0.1.1
 
 Initial visible public extraction of the unofficial TypeScript Codex runtime.

package/dist/ClientNotification-B6-FhXQf.d.ts

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

package/dist/{DynamicToolCallResponse-D2OVpa4p.d.ts → DynamicToolCallResponse-82DFjES2.d.ts}

@@ -1,4 +1,4 @@
-import { D as DynamicToolCallOutputContentItem } from './thread_event_store-BIS0qzhi.js';
+import { e as DynamicToolCallOutputContentItem } from './ServerRequest-B5cKVJjr.js';
 
 type DynamicToolCallResponse = {
     contentItems: Array<DynamicToolCallOutputContentItem>;

package/dist/DynamicToolSpec-CfnhqAYK.d.ts

@@ -0,0 +1,29 @@
+import { a as ModeKind } from './TurnSteerResponse-0kBCfplh.js';
+import { f as ReasoningEffort, J as JsonValue } from './ServerRequest-B5cKVJjr.js';
+
+/**
+ * Settings for a collaboration mode.
+ */
+type Settings = {
+    model: string;
+    reasoning_effort: ReasoningEffort | null;
+    developer_instructions: string | null;
+};
+
+/**
+ * Collaboration mode for a Codex session.
+ */
+type CollaborationMode = {
+    mode: ModeKind;
+    settings: Settings;
+};
+
+type DynamicToolSpec = {
+    namespace?: string;
+    name: string;
+    description: string;
+    inputSchema: JsonValue;
+    deferLoading?: boolean;
+};
+
+export type { CollaborationMode as C, DynamicToolSpec as D, Settings as S };

package/dist/PermissionsRequestApprovalResponse-DxzPPDRb.d.ts

@@ -0,0 +1,55 @@
+import { E as ExecPolicyAmendment, N as NetworkPolicyAmendment, A as AdditionalNetworkPermissions, g as AdditionalFileSystemPermissions, J as JsonValue } from './ServerRequest-B5cKVJjr.js';
+
+type CommandExecutionApprovalDecision = "accept" | "acceptForSession" | {
+    "acceptWithExecpolicyAmendment": {
+        execpolicy_amendment: ExecPolicyAmendment;
+    };
+} | {
+    "applyNetworkPolicyAmendment": {
+        network_policy_amendment: NetworkPolicyAmendment;
+    };
+} | "decline" | "cancel";
+
+type CommandExecutionRequestApprovalResponse = {
+    decision: CommandExecutionApprovalDecision;
+};
+
+type FileChangeApprovalDecision = "accept" | "acceptForSession" | "decline" | "cancel";
+
+type FileChangeRequestApprovalResponse = {
+    decision: FileChangeApprovalDecision;
+};
+
+type GrantedPermissionProfile = {
+    network?: AdditionalNetworkPermissions;
+    fileSystem?: AdditionalFileSystemPermissions;
+};
+
+type McpServerElicitationAction = "accept" | "decline" | "cancel";
+
+type McpServerElicitationRequestResponse = {
+    action: McpServerElicitationAction;
+    /**
+     * Structured user input for accepted elicitations, mirroring RMCP `CreateElicitationResult`.
+     *
+     * This is nullable because decline/cancel responses have no content.
+     */
+    content: JsonValue | null;
+    /**
+     * Optional client metadata for form-mode action handling.
+     */
+    _meta: JsonValue | null;
+};
+
+type PermissionGrantScope = "turn" | "session";
+
+type PermissionsRequestApprovalResponse = {
+    permissions: GrantedPermissionProfile;
+    scope: PermissionGrantScope;
+    /**
+     * Review every subsequent command in this turn before normal sandboxed execution.
+     */
+    strictAutoReview?: boolean;
+};
+
+export type { CommandExecutionRequestApprovalResponse as C, FileChangeRequestApprovalResponse as F, GrantedPermissionProfile as G, McpServerElicitationRequestResponse as M, PermissionsRequestApprovalResponse as P, CommandExecutionApprovalDecision as a, FileChangeApprovalDecision as b, McpServerElicitationAction as c, PermissionGrantScope as d };

package/dist/ProviderStatusBanner-BlP6lzwE.d.ts

@@ -0,0 +1,441 @@
+import * as React$1 from 'react';
+import { MutableRefObject, ReactNode } from 'react';
+import { U as UserInput, a4 as UserMessageTurnItem } from './protocol-mpBcYHrm.js';
+import { T as ToolRequestUserInputResponse } from './ToolRequestUserInputResponse-zcPLwbiK.js';
+import { R as RequestId, T as ToolRequestUserInputQuestion } from './ToolRequestUserInputQuestion-CeZa5X1J.js';
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+import { LegendListRef } from '@legendapp/list/react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { a as Turn } from './thread-history-builder-zW0zeqcS.js';
+
+type CodexModelOption = {
+    slug: string;
+    name: string;
+    shortName?: string;
+    subProvider?: string;
+    description: string;
+};
+type ProviderDriverKind = "codex" | (string & {});
+type ProviderInstanceId = string;
+type ProviderInstanceEntry = {
+    accentColor?: string;
+    continuationGroupKey?: string;
+    displayName: string;
+    driverKind: ProviderDriverKind;
+    instanceId: ProviderInstanceId;
+    isAvailable: boolean;
+    snapshot: {
+        message?: string | null;
+    };
+    status: "ready" | "warning" | "error" | "disabled" | "loading";
+};
+type CodexReasoningEffort = "low" | "medium" | "high" | "xhigh";
+type CodexReasoningEffortOption = {
+    value: CodexReasoningEffort;
+    label: string;
+    description: string;
+};
+declare const defaultCodexModel = "gpt-5.5";
+declare const defaultCodexReasoningEffort: CodexReasoningEffort;
+declare const codexModelOptions: readonly CodexModelOption[];
+declare const defaultCodexProviderInstance: ProviderInstanceEntry;
+declare const codexReasoningEffortOptions: readonly CodexReasoningEffortOption[];
+declare function resolveCodexModelOption(model: string): CodexModelOption;
+declare function resolveCodexReasoningEffortOption(effort: string): CodexReasoningEffortOption;
+declare function isCodexReasoningEffort(value: string): value is CodexReasoningEffort;
+declare function resolveCodexReasoningEffortForModel(model: string, effort: string | null | undefined): CodexReasoningEffort;
+
+type PendingUserInputQuestion = Omit<ToolRequestUserInputQuestion, "options"> & {
+    options: NonNullable<ToolRequestUserInputQuestion["options"]>;
+};
+type PendingUserInput = {
+    requestId: RequestId;
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    questions: readonly PendingUserInputQuestion[];
+};
+interface PendingUserInputDraftAnswer {
+    selectedOptionLabels?: string[];
+    customAnswer?: string;
+}
+interface PendingUserInputProgress {
+    activeDraft: PendingUserInputDraftAnswer | undefined;
+    activeQuestion: PendingUserInputQuestion | null;
+    answeredQuestionCount: number;
+    canAdvance: boolean;
+    customAnswer: string;
+    isComplete: boolean;
+    isLastQuestion: boolean;
+    questionIndex: number;
+    resolvedAnswer: string[] | null;
+    selectedOptionLabels: string[];
+    usingCustomAnswer: boolean;
+}
+declare function normalizePendingUserInputQuestion(question: ToolRequestUserInputQuestion): PendingUserInputQuestion;
+declare function derivePendingUserInputProgress(questions: ReadonlyArray<PendingUserInputQuestion>, draftAnswers: Record<string, PendingUserInputDraftAnswer>, questionIndex: number): PendingUserInputProgress;
+declare function togglePendingUserInputOptionSelection(optionLabel: string): PendingUserInputDraftAnswer;
+declare function setPendingUserInputCustomAnswer(draft: PendingUserInputDraftAnswer | undefined, customAnswer: string): PendingUserInputDraftAnswer;
+declare function buildRequestUserInputResponse(request: PendingUserInput, draftAnswers: Record<string, PendingUserInputDraftAnswer>): ToolRequestUserInputResponse;
+declare function buildPendingUserInputAnswers(questions: ReadonlyArray<PendingUserInputQuestion>, draftAnswers: Record<string, PendingUserInputDraftAnswer>): Record<string, string[]> | null;
+declare function countAnsweredPendingUserInputQuestions(questions: ReadonlyArray<PendingUserInputQuestion>, draftAnswers: Record<string, PendingUserInputDraftAnswer>): number;
+declare function resolvePendingUserInputAnswer(question: PendingUserInputQuestion, draft: PendingUserInputDraftAnswer | undefined): string[] | null;
+
+type ComposerTriggerKind = "path" | "skill" | "slash-command";
+type BuiltInComposerSlashCommand = "default" | "model" | "plan";
+type ComposerSlashCommand = BuiltInComposerSlashCommand | (string & {});
+type ComposerTrigger = {
+    kind: ComposerTriggerKind;
+    query: string;
+    rangeEnd: number;
+    rangeStart: number;
+};
+declare function detectComposerTrigger(text: string, cursorInput: number): ComposerTrigger | null;
+declare function replaceTextRange(text: string, rangeStart: number, rangeEnd: number, replacement: string): {
+    cursor: number;
+    text: string;
+};
+declare function parseStandaloneComposerSlashCommand(text: string): ComposerSlashCommand | null;
+
+type MentionBinding = {
+    mention: string;
+    path: string;
+};
+type MentionBindingRange = {
+    binding: MentionBinding;
+    range: {
+        end: number;
+        start: number;
+    };
+};
+declare function normalizeMentionBindingsForText(text: string, bindings: readonly MentionBinding[]): MentionBinding[];
+declare function mentionBindingRangesForText(text: string, bindings: readonly MentionBinding[]): MentionBindingRange[];
+declare function mentionBindingsAfterReplacement(input: {
+    currentBindings: readonly MentionBinding[];
+    insertedBinding: MentionBinding;
+    nextText: string;
+    replacement: string;
+    rangeEnd: number;
+    rangeStart: number;
+    text: string;
+}): MentionBinding[];
+declare function findNextMentionTokenRange(text: string, token: string, from: number): {
+    end: number;
+    start: number;
+} | null;
+
+type ComposerMentionTarget = {
+    binding: MentionBinding;
+    displayName: string;
+    label: string;
+    mention: string;
+    path: string;
+};
+declare function searchComposerMentionTargets(input: {
+    query: string;
+    targets: readonly ComposerMentionTarget[];
+}): ComposerMentionTarget[];
+
+type ContextWindowSnapshot = {
+    cachedInputTokens: number | null;
+    compactsAutomatically: boolean;
+    durationMs: number | null;
+    inputTokens: number | null;
+    lastCachedInputTokens: number | null;
+    lastInputTokens: number | null;
+    lastOutputTokens: number | null;
+    lastReasoningOutputTokens: number | null;
+    lastUsedTokens: number | null;
+    maxTokens: number | null;
+    outputTokens: number | null;
+    reasoningOutputTokens: number | null;
+    remainingPercentage: number | null;
+    remainingTokens: number | null;
+    toolUses: number | null;
+    totalProcessedTokens: number | null;
+    updatedAt: string;
+    usedPercentage: number | null;
+    usedTokens: number;
+};
+
+type RealtimeConversationPhase = "Inactive" | "Starting" | "Active" | "Stopping";
+type RealtimeConversationUiState = {
+    disabled?: boolean;
+    error?: string | null;
+    phase: RealtimeConversationPhase;
+    realtimeSessionId?: string | null;
+    requestedClose: boolean;
+    transport: "webrtc";
+    onStart: () => void;
+    onStop: () => void;
+};
+type RealtimeConversationControlState = {
+    action: "start" | "stop";
+    isActive: boolean;
+    isBusy: boolean;
+    label: string;
+    title: string;
+};
+declare function isRealtimeConversationLive(phase: RealtimeConversationPhase): boolean;
+declare function getRealtimeConversationControlState(realtimeConversation: Pick<RealtimeConversationUiState, "error" | "phase" | "requestedClose">): RealtimeConversationControlState;
+declare class RecordingMeterState {
+    private readonly history;
+    private env;
+    private noiseEma;
+    nextText(peak: number): string;
+}
+
+interface ComposerImageAttachment {
+    id: string;
+    file: File;
+    name: string;
+    type: string;
+    size: number;
+    previewUrl: string | null;
+}
+interface ExpandedImageItem {
+    src: string;
+    name: string;
+}
+interface ExpandedImagePreview {
+    images: ExpandedImageItem[];
+    index: number;
+}
+interface PersistedComposerDraftImageAttachment {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    dataUrl: string;
+}
+interface ComposerImageValidationResult {
+    accepted: File[];
+    error: string | null;
+}
+declare const WORKSPACE_CHAT_MAX_IMAGE_ATTACHMENTS = 8;
+declare const WORKSPACE_CHAT_MAX_IMAGE_BYTES: number;
+declare function isAcceptedComposerImageFile(file: File): boolean;
+declare function validateComposerImageFiles(input: {
+    currentCount?: number;
+    files: Iterable<File>;
+    maxCount?: number;
+    maxSizeBytes?: number;
+}): ComposerImageValidationResult;
+declare function createComposerImageAttachments(files: Iterable<File>, options?: {
+    createId?: () => string;
+    createObjectURL?: (file: File) => string;
+}): ComposerImageAttachment[];
+declare function persistComposerDraftAttachments(attachments: Iterable<ComposerImageAttachment>, readFileAsDataUrl?: (file: File) => Promise<string>): Promise<PersistedComposerDraftImageAttachment[]>;
+declare function restoreComposerDraftAttachments(attachments: Iterable<PersistedComposerDraftImageAttachment>, options?: {
+    createObjectURL?: (file: File) => string;
+}): ComposerImageAttachment[];
+declare function revokeComposerImageAttachments(attachments: Iterable<ComposerImageAttachment>, revokeObjectURL?: (url: string) => void): void;
+declare function buildExpandedImagePreview(attachments: ReadonlyArray<ComposerImageAttachment>, selectedAttachmentId: string): ExpandedImagePreview | null;
+
+interface ComposerDraftState {
+    prompt: string;
+    model: string | null;
+    effort: CodexReasoningEffort | null;
+    images: ComposerImageAttachment[];
+    persistedImages: PersistedComposerDraftImageAttachment[];
+}
+type ComposerDraftKey = string;
+type PersistedComposerDraftState = Omit<ComposerDraftState, "images">;
+type ComposerDraftStoreState = {
+    draftsByKey: Record<string, ComposerDraftState>;
+    favoriteModels: string[];
+    stickyEffort: CodexReasoningEffort | null;
+    stickyModel: string | null;
+    addImages: (key: ComposerDraftKey, images: ComposerImageAttachment[]) => void;
+    clearComposerContent: (key: ComposerDraftKey) => void;
+    clearDraft: (key: ComposerDraftKey) => void;
+    ensureDraft: (key: ComposerDraftKey) => ComposerDraftState;
+    getDraft: (key: ComposerDraftKey) => ComposerDraftState;
+    removeImage: (key: ComposerDraftKey, imageId: string) => void;
+    setEffort: (key: ComposerDraftKey, effort: CodexReasoningEffort | null) => void;
+    setFavoriteModels: (models: string[]) => void;
+    setModel: (key: ComposerDraftKey, model: string | null) => void;
+    setPrompt: (key: ComposerDraftKey, prompt: string) => void;
+    syncPersistedImages: (key: ComposerDraftKey, images: PersistedComposerDraftImageAttachment[]) => void;
+};
+declare function assistantComposerDraftKey(input: {
+    scope: string;
+    threadId: string | null;
+}): ComposerDraftKey;
+declare function readLegacyComposerDraft(key: ComposerDraftKey, storage?: Storage | null): PersistedComposerDraftState | null;
+declare function resolveDraftModel(draft: Pick<ComposerDraftState, "model">): string;
+declare function resolveDraftEffort(draft: Pick<ComposerDraftState, "effort">, model?: string): CodexReasoningEffort;
+declare const useComposerDraftStore: zustand.UseBoundStore<Omit<zustand.StoreApi<ComposerDraftStoreState>, "setState" | "persist"> & {
+    setState(partial: ComposerDraftStoreState | Partial<ComposerDraftStoreState> | ((state: ComposerDraftStoreState) => ComposerDraftStoreState | Partial<ComposerDraftStoreState>), replace?: false | undefined): unknown;
+    setState(state: ComposerDraftStoreState | ((state: ComposerDraftStoreState) => ComposerDraftStoreState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<ComposerDraftStoreState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ComposerDraftStoreState) => void) => () => void;
+        onFinishHydration: (fn: (state: ComposerDraftStoreState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<ComposerDraftStoreState, unknown, unknown>>;
+    };
+}>;
+declare function useComposerThreadDraft(key: ComposerDraftKey): ComposerDraftState;
+
+type ChatComposerSubmitPayload = {
+    files: File[];
+    effort: CodexReasoningEffort;
+    items: UserInput[];
+    mentionBindings: MentionBinding[];
+    model: string;
+    text: string;
+};
+type ChatComposerInteractionMode = "default" | "plan";
+type ChatComposerRuntimeMode = "approval-required" | "auto-accept-edits" | "full-access";
+type ChatComposerCommand = {
+    description: string;
+    disabled?: boolean;
+    group?: string;
+    label?: string;
+    name: ComposerSlashCommand;
+    unavailableReason?: string;
+};
+type ChatComposerSkill = {
+    description?: string;
+    disabled?: boolean;
+    label?: string;
+    name: string;
+    unavailableReason?: string;
+};
+type ChatComposerHandle = {
+    clear: () => void;
+    focusAt: (cursor: number) => void;
+    focusAtEnd: () => void;
+    getSendContext: () => ChatComposerSubmitPayload;
+    insertTextAtCursor: (text: string, options?: {
+        source?: "manual" | "realtime";
+    }) => void;
+    insertRecordingMeterPlaceholder: (text: string) => string;
+    readSnapshot: () => {
+        cursor: number;
+        expandedCursor: number;
+        value: string;
+    };
+    removeRecordingMeterPlaceholder: (id: string) => void;
+    replaceRecordingMeterPlaceholder: (id: string, text: string) => void;
+    resetCursorState: (options?: {
+        cursor?: number;
+        detectTrigger?: boolean;
+        prompt?: string;
+    }) => void;
+    setDraft: (draft: {
+        mentionBindings?: MentionBinding[];
+        message: string;
+    }) => void;
+    submit: () => void;
+    updateRecordingMeterInPlace: (id: string, text: string) => boolean;
+};
+declare const ChatComposer: React$1.ForwardRefExoticComponent<{
+    className?: string;
+    disabled?: boolean;
+    draftKey: ComposerDraftKey;
+    editorAriaLabel?: string;
+    isConnecting?: boolean;
+    isEnvironmentUnavailable?: boolean;
+    isRunning?: boolean;
+    isSending?: boolean;
+    interactionMode?: ChatComposerInteractionMode;
+    contextWindow?: ContextWindowSnapshot | null;
+    mentionRefs: ComposerMentionTarget[];
+    modelOptions?: readonly CodexModelOption[];
+    pendingUserInput?: PendingUserInput | null;
+    pendingRequestDisabled?: boolean;
+    placeholder?: string;
+    planFollowUpTitle?: string | null;
+    planSidebarLabel?: string;
+    planSidebarOpen?: boolean;
+    realtimeConversation?: RealtimeConversationUiState | null;
+    runtimeMode?: ChatComposerRuntimeMode;
+    showPlanFollowUpPrompt?: boolean;
+    showInteractionModeToggle?: boolean;
+    showPlanToggle?: boolean;
+    composerCommands?: readonly ChatComposerCommand[];
+    composerSkills?: readonly ChatComposerSkill[];
+    onCommand?: (command: ComposerSlashCommand) => void;
+    onComposerError?: (message: string) => void;
+    onImplementPlanInNewThread?: () => void;
+    onRuntimeModeChange?: (mode: ChatComposerRuntimeMode) => void;
+    onToggleInteractionMode?: () => void;
+    onTogglePlanSidebar?: () => void;
+    onPendingRequestDismiss?: () => void;
+    onPendingRequestSubmit?: (response: ToolRequestUserInputResponse) => boolean | void;
+    onInterrupt: () => void;
+    scheduleStickToBottom?: () => void;
+    shouldAutoScrollRef?: MutableRefObject<boolean>;
+    onSend: () => void | Promise<void>;
+} & React$1.RefAttributes<ChatComposerHandle>>;
+
+type ComposerBannerStackItem = {
+    id: string;
+    title: ReactNode;
+    description?: ReactNode;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    actions?: ReactNode;
+    dismissLabel?: string;
+    icon?: ReactNode;
+    onDismiss?: () => void;
+    variant?: "error" | "info" | "success" | "warning";
+    tone?: "default" | "destructive";
+};
+declare function ComposerBannerStack({ className, items, }: {
+    className?: string;
+    items: readonly ComposerBannerStackItem[];
+}): react_jsx_runtime.JSX.Element | null;
+
+type MessagesTimelineProps = {
+    activeTurnStartedAt: string | null;
+    errors: string[];
+    isWorking: boolean;
+    listRef: React.RefObject<LegendListRef | null>;
+    onImageExpand: (preview: ExpandedImagePreview) => void;
+    onIsAtEndChange: (isAtEnd: boolean) => void;
+    optimisticUserMessages: readonly UserMessageTurnItem[];
+    runtimeError: string | null;
+    turns: readonly Turn[];
+    warnings: string[];
+};
+declare const MessagesTimeline: React$1.NamedExoticComponent<MessagesTimelineProps>;
+
+type ChatViewRenderComposerControls = {
+    prepareForOptimisticAppend: () => Promise<void>;
+    scheduleStickToBottom: () => void;
+};
+type ChatViewProps = {
+    actions?: ReactNode;
+    bannerItems?: readonly ComposerBannerStackItem[];
+    className?: string;
+    composer: ReactNode;
+    headerLeading?: ReactNode;
+    listRef: React.RefObject<LegendListRef | null>;
+    subtitle?: ReactNode;
+    threadKey: string;
+    timeline: Omit<MessagesTimelineProps, "listRef" | "onImageExpand" | "onIsAtEndChange">;
+    title: ReactNode;
+    onControlsChange?: (controls: ChatViewRenderComposerControls | null) => void;
+    onIsAtEndChange?: (isAtEnd: boolean) => void;
+};
+declare const ChatView: React$1.NamedExoticComponent<ChatViewProps>;
+
+type ProviderStatus = {
+    displayName?: string | null;
+    driver?: string | null;
+    message?: string | null;
+    status: "disabled" | "error" | "limited" | "ready" | "warning";
+};
+declare const ProviderStatusBanner: React$1.NamedExoticComponent<{
+    status: ProviderStatus | null;
+}>;
+
+export { ChatComposer as $, isAcceptedComposerImageFile as A, isCodexReasoningEffort as B, type ChatComposerHandle as C, isRealtimeConversationLive as D, type ExpandedImagePreview as E, mentionBindingRangesForText as F, mentionBindingsAfterReplacement as G, normalizeMentionBindingsForText as H, persistComposerDraftAttachments as I, resolveCodexModelOption as J, resolveCodexReasoningEffortForModel as K, resolveCodexReasoningEffortOption as L, type MentionBinding as M, resolveDraftEffort as N, resolveDraftModel as O, type PersistedComposerDraftImageAttachment as P, restoreComposerDraftAttachments as Q, type RealtimeConversationControlState as R, revokeComposerImageAttachments as S, useComposerDraftStore as T, useComposerThreadDraft as U, validateComposerImageFiles as V, WORKSPACE_CHAT_MAX_IMAGE_ATTACHMENTS as W, type PendingUserInput as X, type ContextWindowSnapshot as Y, type MessagesTimelineProps as Z, type ChatViewProps as _, type ChatComposerSubmitPayload as a, type ChatComposerRuntimeMode as a0, type ProviderStatus as a1, type ComposerBannerStackItem as a2, type ChatComposerInteractionMode as a3, type ComposerMentionTarget as a4, type ComposerSlashCommand as a5, type ComposerTriggerKind as a6, type PendingUserInputDraftAnswer as a7, type ComposerTrigger as a8, type BuiltInComposerSlashCommand as a9, type ChatComposerCommand as aa, type ChatComposerSkill as ab, ChatView as ac, ComposerBannerStack as ad, type ExpandedImageItem as ae, MessagesTimeline as af, type PendingUserInputProgress as ag, type PendingUserInputQuestion as ah, type PersistedComposerDraftState as ai, ProviderStatusBanner as aj, buildPendingUserInputAnswers as ak, buildRequestUserInputResponse as al, countAnsweredPendingUserInputQuestions as am, derivePendingUserInputProgress as an, detectComposerTrigger as ao, findNextMentionTokenRange as ap, normalizePendingUserInputQuestion as aq, parseStandaloneComposerSlashCommand as ar, readLegacyComposerDraft as as, replaceTextRange as at, resolvePendingUserInputAnswer as au, searchComposerMentionTargets as av, setPendingUserInputCustomAnswer as aw, togglePendingUserInputOptionSelection as ax, type ChatViewRenderComposerControls as b, type CodexModelOption as c, type CodexReasoningEffort as d, type CodexReasoningEffortOption as e, type ComposerDraftKey as f, type ComposerDraftState as g, type ComposerImageAttachment as h, type ComposerImageValidationResult as i, type MentionBindingRange as j, type ProviderDriverKind as k, type ProviderInstanceEntry as l, type ProviderInstanceId as m, type RealtimeConversationPhase as n, type RealtimeConversationUiState as o, RecordingMeterState as p, WORKSPACE_CHAT_MAX_IMAGE_BYTES as q, assistantComposerDraftKey as r, buildExpandedImagePreview as s, codexModelOptions as t, codexReasoningEffortOptions as u, createComposerImageAttachments as v, defaultCodexModel as w, defaultCodexProviderInstance as x, defaultCodexReasoningEffort as y, getRealtimeConversationControlState as z };