@jrkropp/codex-js-react 0.2.0

package/dist/internal/chat-ui/components/ChatMarkdown.d.ts

@@ -0,0 +1,7 @@
+type ChatMarkdownProps = {
+    cwd?: string | undefined;
+    isStreaming?: boolean;
+    text: string;
+};
+export declare const ChatMarkdown: import("react").NamedExoticComponent<ChatMarkdownProps>;
+export default ChatMarkdown;

package/dist/internal/chat-ui/components/ComposerPromptEditor.d.ts

@@ -0,0 +1,34 @@
+import { type ComposerPromptSnapshot } from "./chat/composer-editor-mentions.js";
+import { type ComposerTrigger } from "./chat/composer-logic.js";
+import { type MentionBinding } from "./chat/mention-bindings.js";
+import { type ComposerMentionTarget } from "./chat/composer-mention-targets.js";
+export type ComposerPromptEditorHandle = {
+    clear: () => void;
+    focusAt: (cursor: number) => void;
+    focusAtEnd: () => void;
+    insertTextAtCursor: (text: string, options?: {
+        source?: "manual" | "realtime";
+    }) => void;
+    insertMention: (mention: ComposerMentionTarget, trigger: ComposerTrigger | null) => void;
+    insertRecordingMeterPlaceholder: (text: string) => string;
+    readSnapshot: () => ComposerPromptSnapshot;
+    removeRecordingMeterPlaceholder: (id: string) => void;
+    replaceRecordingMeterPlaceholder: (id: string, text: string) => void;
+    setTextContentWithMentionBindings: (input: {
+        mentionBindings?: MentionBinding[];
+        text: string;
+    }) => void;
+    updateRecordingMeterInPlace: (id: string, text: string) => boolean;
+};
+type ComposerPromptEditorProps = {
+    ariaLabel?: string;
+    className?: string;
+    disabled?: boolean;
+    placeholder?: string;
+    onCommandKey?: (key: "ArrowDown" | "ArrowUp" | "Enter" | "Tab", event: KeyboardEvent) => boolean;
+    onSnapshotChange?: (snapshot: ComposerPromptSnapshot) => void;
+    onSubmit?: () => void;
+    onTriggerChange?: (trigger: ComposerTrigger | null) => void;
+};
+export declare const ComposerPromptEditor: import("react").ForwardRefExoticComponent<ComposerPromptEditorProps & import("react").RefAttributes<ComposerPromptEditorHandle>>;
+export {};

package/dist/internal/chat-ui/components/chat/ChangedFilesTree.d.ts

@@ -0,0 +1,5 @@
+import { type TimelineChangedFile } from "./ChangedFilesTree.logic.js";
+export declare const AssistantChangedFilesSection: import("react").NamedExoticComponent<{
+    files: readonly TimelineChangedFile[];
+    turnId: string | null;
+}>;

package/dist/internal/chat-ui/components/chat/ChangedFilesTree.logic.d.ts

@@ -0,0 +1,33 @@
+import type { CoreTurnItem as TurnItem } from "@jrkropp/codex-js/client";
+type FileChangeTurnItem = Extract<TurnItem, {
+    type: "FileChange";
+}>;
+type FileChange = FileChangeTurnItem["changes"][string];
+export type TimelineChangedFile = {
+    additions: number;
+    changeType: FileChange["type"];
+    deletions: number;
+    path: string;
+};
+export type TimelineChangedFileStat = {
+    additions: number;
+    deletions: number;
+};
+export type TimelineChangedFileTreeNode = {
+    children: TimelineChangedFileTreeNode[];
+    kind: "directory";
+    name: string;
+    path: string;
+    stat: TimelineChangedFileStat;
+} | {
+    file: TimelineChangedFile;
+    kind: "file";
+    name: string;
+    path: string;
+    stat: TimelineChangedFileStat;
+};
+export declare function changedFilesForFileChangeTurnItem(item: FileChangeTurnItem): TimelineChangedFile[];
+export declare function summarizeChangedFileStats(files: readonly TimelineChangedFile[]): TimelineChangedFileStat;
+export declare function hasNonZeroChangedFileStat(stat: TimelineChangedFileStat): boolean;
+export declare function buildChangedFilesTree(files: readonly TimelineChangedFile[]): TimelineChangedFileTreeNode[];
+export {};

package/dist/internal/chat-ui/components/chat/ChatComposer.d.ts

@@ -0,0 +1,103 @@
+import { type MutableRefObject } from "react";
+import type { CoreUserInput as UserInput } from "@jrkropp/codex-js/client";
+import type { CodexModelOption, CodexReasoningEffort } from "../../lib/modelSelection.js";
+import type { ToolRequestUserInputResponse } from "@jrkropp/codex-js/client";
+import { type PendingUserInput } from "../../pendingUserInput.js";
+import { type ComposerSlashCommand } from "./composer-logic.js";
+import type { MentionBinding } from "./mention-bindings.js";
+import { type ComposerMentionTarget } from "./composer-mention-targets.js";
+import type { ContextWindowSnapshot } from "../../lib/contextWindow.js";
+import type { RealtimeConversationUiState } from "./composer-realtime-conversation.logic.js";
+import { type ComposerDraftKey } from "./composer-draft.client.js";
+export type ChatComposerSubmitPayload = {
+    files: File[];
+    effort: CodexReasoningEffort;
+    items: UserInput[];
+    mentionBindings: MentionBinding[];
+    model: string;
+    text: string;
+};
+export type ChatComposerInteractionMode = "default" | "plan";
+export type ChatComposerRuntimeMode = "approval-required" | "auto-accept-edits" | "full-access";
+export type ChatComposerCommand = {
+    description: string;
+    disabled?: boolean;
+    group?: string;
+    label?: string;
+    name: ComposerSlashCommand;
+    unavailableReason?: string;
+};
+export type ChatComposerSkill = {
+    description?: string;
+    disabled?: boolean;
+    label?: string;
+    name: string;
+    unavailableReason?: string;
+};
+export 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;
+};
+export declare const ChatComposer: import("react").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>;
+} & import("react").RefAttributes<ChatComposerHandle>>;

package/dist/internal/chat-ui/components/chat/ChatView.d.ts

@@ -0,0 +1,23 @@
+import { type LegendListRef } from "@legendapp/list/react";
+import { type ReactNode } from "react";
+import { type ComposerBannerStackItem } from "./ComposerBannerStack.js";
+import { type MessagesTimelineProps } from "./MessagesTimeline.js";
+export type ChatViewRenderComposerControls = {
+    prepareForOptimisticAppend: () => Promise<void>;
+    scheduleStickToBottom: () => void;
+};
+export 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;
+};
+export declare const ChatView: import("react").NamedExoticComponent<ChatViewProps>;

package/dist/internal/chat-ui/components/chat/CompactComposerControlsMenu.d.ts

@@ -0,0 +1,16 @@
+import type { CodexReasoningEffort } from "../../lib/modelSelection.js";
+import type { ChatComposerInteractionMode, ChatComposerRuntimeMode } from "./ChatComposer.js";
+export declare const CompactComposerControlsMenu: import("react").NamedExoticComponent<{
+    activePlan?: boolean;
+    disabled?: boolean;
+    effort: CodexReasoningEffort;
+    interactionMode?: ChatComposerInteractionMode;
+    onEffortChange: (effort: CodexReasoningEffort) => void;
+    onRuntimeModeChange?: (mode: ChatComposerRuntimeMode) => void;
+    onToggleInteractionMode?: () => void;
+    onTogglePlanSidebar?: () => void;
+    planSidebarLabel?: string;
+    planSidebarOpen?: boolean;
+    runtimeMode?: ChatComposerRuntimeMode;
+    showInteractionModeToggle?: boolean;
+}>;

package/dist/internal/chat-ui/components/chat/ComposerBannerStack.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNode } from "react";
+export 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";
+};
+export declare function ComposerBannerStack({ className, items, }: {
+    className?: string;
+    items: readonly ComposerBannerStackItem[];
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/internal/chat-ui/components/chat/ComposerCommandMenu.d.ts

@@ -0,0 +1,35 @@
+import type { ComposerSlashCommand, ComposerTriggerKind } from "./composer-logic.js";
+import type { ComposerMentionTarget } from "./composer-mention-targets.js";
+export type ComposerCommandItem = {
+    description: string;
+    id: string;
+    label: string;
+    mention: ComposerMentionTarget;
+    path: string;
+    type: "path";
+} | {
+    command: ComposerSlashCommand;
+    description: string;
+    disabled?: boolean;
+    id: string;
+    label: string;
+    type: "slash-command";
+    unavailableReason?: string;
+} | {
+    description: string;
+    disabled?: boolean;
+    id: string;
+    label: string;
+    name: string;
+    type: "skill";
+    unavailableReason?: string;
+};
+export declare const ComposerCommandMenu: import("react").NamedExoticComponent<{
+    activeItemId: string | null;
+    emptyStateText?: string;
+    isLoading?: boolean;
+    items: ComposerCommandItem[];
+    triggerKind: ComposerTriggerKind | null;
+    onHighlightedItemChange: (itemId: string | null) => void;
+    onSelect: (item: ComposerCommandItem) => void;
+}>;

package/dist/internal/chat-ui/components/chat/ComposerPendingApprovalActions.d.ts

@@ -0,0 +1,9 @@
+export type ApprovalRequestId = string;
+export type ProviderApprovalDecision = "accept" | "acceptForSession" | "cancel" | "decline";
+interface ComposerPendingApprovalActionsProps {
+    isResponding: boolean;
+    requestId: ApprovalRequestId;
+    onRespondToApproval: (requestId: ApprovalRequestId, decision: ProviderApprovalDecision) => Promise<void>;
+}
+export declare const ComposerPendingApprovalActions: import("react").NamedExoticComponent<ComposerPendingApprovalActionsProps>;
+export {};

package/dist/internal/chat-ui/components/chat/ComposerPendingApprovalPanel.d.ts

@@ -0,0 +1,9 @@
+export type PendingApproval = {
+    requestKind: "command" | "file-change" | "file-read";
+};
+interface ComposerPendingApprovalPanelProps {
+    approval: PendingApproval;
+    pendingCount: number;
+}
+export declare const ComposerPendingApprovalPanel: import("react").NamedExoticComponent<ComposerPendingApprovalPanelProps>;
+export {};

package/dist/internal/chat-ui/components/chat/ComposerPendingTerminalContexts.d.ts

@@ -0,0 +1,18 @@
+export interface TerminalContextDraft {
+    expiresAt?: number | null;
+    id: string;
+    label?: string | null;
+    text: string;
+}
+interface ComposerPendingTerminalContextsProps {
+    className?: string;
+    contexts: ReadonlyArray<TerminalContextDraft>;
+}
+interface ComposerPendingTerminalContextChipProps {
+    context: TerminalContextDraft;
+}
+export declare function formatTerminalContextLabel(context: TerminalContextDraft): string;
+export declare function isTerminalContextExpired(context: TerminalContextDraft): boolean;
+export declare function ComposerPendingTerminalContextChip({ context, }: ComposerPendingTerminalContextChipProps): import("react/jsx-runtime").JSX.Element;
+export declare function ComposerPendingTerminalContexts({ className, contexts, }: ComposerPendingTerminalContextsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/internal/chat-ui/components/chat/ComposerPendingUserInputPanel.d.ts

@@ -0,0 +1,12 @@
+import type { PendingUserInput, PendingUserInputDraftAnswer } from "../../pendingUserInput.js";
+export { buildRequestUserInputResponse, derivePendingUserInputProgress, setPendingUserInputCustomAnswer, togglePendingUserInputOptionSelection, type PendingUserInputDraftAnswer, type PendingUserInputProgress, } from "../../pendingUserInput.js";
+export declare function ComposerPendingUserInputPanel({ answers, disabled, isResponding, questionIndex, request, onAdvance, onDismiss, onToggleOption, }: {
+    answers: Record<string, PendingUserInputDraftAnswer>;
+    disabled?: boolean;
+    isResponding?: boolean;
+    questionIndex: number;
+    request: PendingUserInput | null;
+    onAdvance: () => void;
+    onDismiss: () => void;
+    onToggleOption: (questionId: string, optionLabel: string) => void;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/internal/chat-ui/components/chat/ComposerPlanFollowUpBanner.d.ts

@@ -0,0 +1,3 @@
+export declare const ComposerPlanFollowUpBanner: import("react").NamedExoticComponent<{
+    planTitle: string | null;
+}>;

package/dist/internal/chat-ui/components/chat/ComposerPrimaryActions.d.ts

@@ -0,0 +1,17 @@
+import { type PendingActionState } from "./ComposerPrimaryActions.logic.js";
+export declare const ComposerPrimaryActions: import("react").NamedExoticComponent<{
+    compact: boolean;
+    disabled?: boolean;
+    hasSendableContent: boolean;
+    isConnecting?: boolean;
+    isEnvironmentUnavailable?: boolean;
+    isRunning: boolean;
+    isSending: boolean;
+    pendingAction: PendingActionState | null;
+    promptHasText?: boolean;
+    preserveComposerFocusOnPointerDown?: boolean;
+    showPlanFollowUpPrompt?: boolean;
+    onInterrupt: () => void;
+    onImplementPlanInNewThread?: () => void;
+    onPreviousPendingQuestion: () => void;
+}>;

package/dist/internal/chat-ui/components/chat/ComposerPrimaryActions.logic.d.ts

@@ -0,0 +1,13 @@
+export interface PendingActionState {
+    questionIndex: number;
+    isLastQuestion: boolean;
+    canAdvance: boolean;
+    isResponding: boolean;
+    isComplete: boolean;
+}
+export declare function formatPendingPrimaryActionLabel(input: {
+    compact: boolean;
+    isLastQuestion: boolean;
+    isResponding: boolean;
+    questionIndex: number;
+}): "Submitting..." | "Submit" | "Next" | "Next question" | "Submit answers" | "Submit answer";

package/dist/internal/chat-ui/components/chat/ComposerRealtimeConversationControl.d.ts

@@ -0,0 +1,7 @@
+import { type RealtimeConversationUiState } from "./composer-realtime-conversation.logic.js";
+export declare const ComposerRealtimeConversationControl: import("react").NamedExoticComponent<{
+    compact: boolean;
+    disabled?: boolean;
+    preserveComposerFocusOnPointerDown?: boolean;
+    realtimeConversation: RealtimeConversationUiState;
+}>;

package/dist/internal/chat-ui/components/chat/ContextWindowMeter.d.ts

@@ -0,0 +1,4 @@
+import { type ContextWindowSnapshot } from "../../lib/contextWindow.js";
+export declare function ContextWindowMeter(props: {
+    usage: ContextWindowSnapshot;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/internal/chat-ui/components/chat/ExpandedImageDialog.d.ts

@@ -0,0 +1,5 @@
+import type { ExpandedImagePreview } from "./composer-image-attachments.js";
+export declare const ExpandedImageDialog: import("react").NamedExoticComponent<{
+    preview: ExpandedImagePreview;
+    onClose: () => void;
+}>;

package/dist/internal/chat-ui/components/chat/MessagesTimeline.d.ts

@@ -0,0 +1,16 @@
+import { type LegendListRef } from "@legendapp/list/react";
+import type { CoreUserMessageTurnItem as UserMessageTurnItem, ThreadHistoryTurn as Turn } from "@jrkropp/codex-js/client";
+import type { ExpandedImagePreview } from "./composer-image-attachments.js";
+export 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[];
+};
+export declare const MessagesTimeline: import("react").NamedExoticComponent<MessagesTimelineProps>;

package/dist/internal/chat-ui/components/chat/MessagesTimeline.logic.d.ts

@@ -0,0 +1,113 @@
+import type { CoreTurnItem as TurnItem, CoreUserInput as UserInput, CoreUserMessageTurnItem as UserMessageTurnItem, ThreadHistoryTurn as Turn } from "@jrkropp/codex-js/client";
+import { type TimelineChangedFile } from "./ChangedFilesTree.logic.js";
+export declare const TIMELINE_WORKING_ROW_ID = "working-indicator-row";
+export declare const MAX_VISIBLE_WORK_LOG_ENTRIES = 6;
+type TimelineMessageItem = Extract<TurnItem, {
+    type: "AgentMessage" | "UserMessage";
+}>;
+type TimelineProposedPlanItem = Extract<TurnItem, {
+    type: "Plan";
+}>;
+type TimelineWorkTurnItem = Exclude<TurnItem, TimelineMessageItem | TimelineProposedPlanItem>;
+export type TimelineWorkEntryTone = "error" | "info" | "thinking" | "tool";
+export type TimelineWorkEntry = {
+    changedFiles: string[];
+    id: string;
+    item: TimelineWorkTurnItem;
+    itemType: TimelineWorkTurnItem["type"];
+    label: string;
+    preview: string | null;
+    status: string | null;
+    title: string | null;
+    tone: TimelineWorkEntryTone;
+};
+export type MessagesTimelineRow = {
+    kind: "empty";
+    id: "empty";
+} | {
+    kind: "message";
+    completedAt: string | null;
+    createdAt: string | null;
+    durationStart: string | null;
+    id: string;
+    item: TimelineMessageItem;
+    role: "assistant" | "user";
+    changedFiles: TimelineChangedFile[];
+    showAssistantCopyButton: boolean;
+    showCompletionDivider: boolean;
+    turnId: string | null;
+} | {
+    kind: "proposed-plan";
+    createdAt: string | null;
+    id: string;
+    item: TimelineProposedPlanItem;
+    turnId: string | null;
+} | {
+    kind: "work";
+    createdAt: string | null;
+    groupedEntries: TimelineWorkEntry[];
+    id: string;
+    turnId: string | null;
+} | {
+    kind: "working";
+    id: typeof TIMELINE_WORKING_ROW_ID;
+    createdAt: string | null;
+} | {
+    kind: "warning";
+    id: string;
+    message: string;
+} | {
+    kind: "error";
+    id: string;
+    message: string;
+};
+export type StableMessagesTimelineRowsState = {
+    byId: Map<string, MessagesTimelineRow>;
+    result: MessagesTimelineRow[];
+};
+export declare function deriveMessagesTimelineRows(input: {
+    turns: readonly Turn[];
+    optimisticUserMessages?: readonly UserMessageTurnItem[];
+    isWorking?: boolean;
+    activeTurnStartedAt?: string | null;
+    running?: boolean;
+    hasPendingRequest?: boolean;
+    warnings: string[];
+    errors: string[];
+    runtimeError: string | null;
+}): MessagesTimelineRow[];
+export declare function computeStableMessagesTimelineRows(rows: MessagesTimelineRow[], previous: StableMessagesTimelineRowsState): StableMessagesTimelineRowsState;
+export declare function shouldShowWorkingRow(input: {
+    isWorking?: boolean;
+    items?: TurnItem[];
+    turns?: readonly Turn[];
+    running?: boolean;
+    hasPendingRequest?: boolean;
+}): boolean;
+export declare function buildOptimisticUserMessageTurnItem(input: {
+    id: string;
+    imageUrls?: readonly string[];
+    items: readonly UserInput[];
+}): UserMessageTurnItem;
+export declare function mergeOptimisticUserMessageTurnItems(items: readonly TurnItem[], optimisticMessages: readonly UserMessageTurnItem[]): TurnItem[];
+export declare function resolveAssistantMessageCopyState(input: {
+    showCopyButton: boolean;
+    streaming: boolean;
+    text: string | null;
+}): {
+    text: string | null;
+    visible: boolean;
+};
+export declare function timelineWorkEntryForTurnItem(item: TurnItem): TimelineWorkEntry | null;
+export declare function visibleTimelineWorkEntries(input: {
+    entries: readonly TimelineWorkEntry[];
+    expanded?: boolean;
+    maxVisible?: number;
+}): {
+    entries: TimelineWorkEntry[];
+    hiddenCount: number;
+};
+export declare function messagesTimelineFingerprint(rows: readonly MessagesTimelineRow[]): string;
+export declare function turnItemTextForCopy(item: TurnItem): string | null;
+export declare function isAssistantCredentialError(message: string): boolean;
+export {};

package/dist/internal/chat-ui/components/chat/ModelListRow.d.ts

@@ -0,0 +1,9 @@
+import type { CodexModelOption } from "../../lib/modelSelection.js";
+export declare const ModelListRow: import("react").NamedExoticComponent<{
+    index: number;
+    isFavorite: boolean;
+    isSelected: boolean;
+    model: CodexModelOption;
+    onSelect: () => void;
+    onToggleFavorite: () => void;
+}>;

package/dist/internal/chat-ui/components/chat/ModelPickerContent.d.ts

@@ -0,0 +1,15 @@
+import { type CodexModelOption, type ProviderInstanceEntry } from "../../lib/modelSelection.js";
+export declare const ModelPickerContent: import("react").NamedExoticComponent<{
+    favoriteModels: readonly string[];
+    instanceEntries?: ReadonlyArray<ProviderInstanceEntry>;
+    model: string;
+    modelOptions: readonly CodexModelOption[];
+    onModelChange: (model: string) => void;
+    onRequestClose?: () => void;
+    onToggleFavorite: (model: string) => void;
+}>;
+export declare function filterCodexModelPickerOptions(input: {
+    favoriteModels: ReadonlySet<string>;
+    modelOptions: readonly CodexModelOption[];
+    query: string;
+}): CodexModelOption[];

package/dist/internal/chat-ui/components/chat/ModelPickerSidebar.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderInstanceEntry, ProviderInstanceId } from "../../lib/modelSelection.js";
+export declare const ModelPickerSidebar: import("react").NamedExoticComponent<{
+    instanceEntries: ReadonlyArray<ProviderInstanceEntry>;
+    onSelectInstance: (instanceId: ProviderInstanceId | "favorites") => void;
+    selectedInstanceId: ProviderInstanceId | "favorites";
+    showComingSoon?: boolean;
+    showFavorites?: boolean;
+}>;

package/dist/internal/chat-ui/components/chat/ProposedPlanCard.d.ts

@@ -0,0 +1,3 @@
+export declare const ProposedPlanCard: import("react").NamedExoticComponent<{
+    planMarkdown: string;
+}>;

package/dist/internal/chat-ui/components/chat/ProviderInstanceIcon.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderDriverKind } from "../../lib/modelSelection.js";
+export declare function providerInstanceInitials(label: string): string;
+export declare const ProviderInstanceIcon: import("react").NamedExoticComponent<{
+    accentColor?: string | undefined;
+    badgeClassName?: string;
+    className?: string;
+    displayName: string;
+    driverKind: ProviderDriverKind;
+    iconClassName?: string;
+    showBadge?: boolean;
+    statusDotClassName?: string;
+}>;

package/dist/internal/chat-ui/components/chat/ProviderModelPicker.d.ts

@@ -0,0 +1,14 @@
+import { type CodexModelOption, type ProviderInstanceEntry } from "../../lib/modelSelection.js";
+export declare const ProviderModelPicker: import("react").NamedExoticComponent<{
+    className?: string;
+    compact?: boolean;
+    disabled?: boolean;
+    favoriteModels: readonly string[];
+    instanceEntries?: ReadonlyArray<ProviderInstanceEntry>;
+    model: string;
+    modelOptions?: readonly CodexModelOption[];
+    open?: boolean;
+    onFavoriteModelsChange: (models: string[]) => void;
+    onModelChange: (model: string) => void;
+    onOpenChange?: (open: boolean) => void;
+}>;

package/dist/internal/chat-ui/components/chat/ProviderStatusBanner.d.ts

@@ -0,0 +1,9 @@
+export type ProviderStatus = {
+    displayName?: string | null;
+    driver?: string | null;
+    message?: string | null;
+    status: "disabled" | "error" | "limited" | "ready" | "warning";
+};
+export declare const ProviderStatusBanner: import("react").NamedExoticComponent<{
+    status: ProviderStatus | null;
+}>;

package/dist/internal/chat-ui/components/chat/TerminalContextInlineChip.d.ts

@@ -0,0 +1,7 @@
+interface TerminalContextInlineChipProps {
+    expired?: boolean;
+    label: string;
+    tooltipText: string;
+}
+export declare function TerminalContextInlineChip(props: TerminalContextInlineChipProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/internal/chat-ui/components/chat/TraitsPicker.d.ts

@@ -0,0 +1,7 @@
+import { type CodexReasoningEffort } from "../../lib/modelSelection.js";
+export declare const TraitsPicker: import("react").NamedExoticComponent<{
+    className?: string;
+    disabled?: boolean;
+    effort: CodexReasoningEffort;
+    onEffortChange: (effort: CodexReasoningEffort) => void;
+}>;