@hachej/boring-agent 0.1.34 → 0.1.35

package/dist/front/index.d.ts

@@ -1,14 +1,14 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import * as ai from 'ai';
 import { FileUIPart, UIMessage, ChatStatus } from 'ai';
 import * as react from 'react';
-import { ReactNode, ComponentType, HTMLAttributes, ComponentProps, FormEvent } from 'react';
-import { T as ToolUiMetadata } from '../tool-ui-DIFNGwYd.js';
-import { S as SendMessageInput, e as SessionSummary } from '../harness-dYuMzxmp.js';
+import { ComponentType, ReactNode, HTMLAttributes, ComponentProps, FormEvent } from 'react';
+import { T as ToolUiMetadata, B as BoringChatPart, d as BoringChatMessage, p as PiChatStatus, u as QueuedUserMessage, e as ChatError, P as PiChatEvent, r as PromptPayload, s as PromptReceipt, F as FollowUpPayload, l as FollowUpReceipt, Q as QueueClearPayload, t as QueueClearReceipt, I as InterruptPayload, h as CommandReceipt, S as StopPayload, v as StopReceipt } from '../piChatEvent-Ck1BAE_m.js';
+import { c as SessionSummary } from '../session-BRovhe0D.js';
 import { Button, Collapsible, CollapsibleContent, CollapsibleTrigger, InputGroupAddon, InputGroupButton, InputGroupTextarea } from '@hachej/boring-ui-kit';
 import { Streamdown } from 'streamdown';
 import { StickToBottom } from 'use-stick-to-bottom';
 import { ClassValue } from 'clsx';
+import 'zod';
 
 interface UploadFileOptions {
     apiBaseUrl?: string;
@@ -22,64 +22,26 @@ interface UploadFileResult {
 }
 declare function uploadFile(file: File, opts?: UploadFileOptions): Promise<UploadFileResult>;
 
-type SlashCommandHandler = (args: string, ctx: SlashCommandContext) => string | void | Promise<string | void>;
-interface SlashCommand {
-    name: string;
-    description: string;
-    /** 'skill' commands are forwarded to the PI agent as `skill: <name>\n\n<args>` instead of running locally. */
-    kind?: 'local' | 'skill';
-    handler: SlashCommandHandler;
-}
-interface SlashCommandContext {
-    sessionId: string;
-    clearMessages: () => void;
-    resetSession: () => void;
-    listCommands: () => SlashCommand[];
-    reloadAgentPlugins: () => Promise<string>;
-    /**
-     * Drives the PluginUpdateStatus banner above the composer. The `/reload`
-     * builtin prefers this over the inline-text path: it calls
-     * `pluginUpdate.run()` which (1) sets the banner to "running", (2)
-     * hits /api/v1/agent/reload, (3) transitions to "success" or "error"
-     * with diagnostics. Returns a short string ack for the assistant
-     * message bubble.
-     */
-    pluginUpdate?: {
-        run: () => Promise<string>;
-    };
-}
-interface CommandRegistry {
-    register(cmd: SlashCommand): void;
-    get(name: string): SlashCommand | undefined;
-    list(): SlashCommand[];
-}
-declare function createCommandRegistry(initial?: SlashCommand[]): CommandRegistry;
-
-type ToolState = 'input-streaming' | 'input-available' | 'approval-requested' | 'approval-responded' | 'output-available' | 'output-error' | 'output-denied';
-
-interface ToolPart {
-    type: string;
-    toolName: string;
-    toolCallId: string;
-    state: ToolState;
-    input?: unknown;
-    output?: unknown;
-    errorText?: string;
-    ui?: ToolUiMetadata;
+/**
+ * Extended-thinking budget. Sent through the agent runtime to providers that
+ * support reasoning controls. 'off' means no reasoning chunks; the higher
+ * tiers progressively allow more think-time.
+ */
+type ThinkingLevel = 'off' | 'low' | 'medium' | 'high';
+/**
+ * Selected model, stored as { provider, id } so the composer can pass through
+ * the agent runtime's registered model IDs rather than a local alias table.
+ * Unqualified legacy aliases are ignored: Boring must not infer a provider
+ * when the runtime owns model selection.
+ */
+interface ModelSelection {
+    provider: string;
+    id: string;
 }
-type ToolRenderer = (part: ToolPart) => ReactNode;
-type ToolRendererOverrides = Partial<Record<string, ToolRenderer>>;
-declare const defaultToolRenderers: Record<string, ToolRenderer>;
-declare function mergeToolRenderers(overrides?: ToolRendererOverrides): Record<string, ToolRenderer>;
-declare function resolveToolRenderer(toolName: string, overrides?: ToolRendererOverrides): ToolRenderer;
-
-type OpenArtifactHandler = (path: string) => void;
-interface ArtifactOpenProviderProps {
-    onOpenArtifact?: OpenArtifactHandler;
-    children: ReactNode;
+interface AvailableModel extends ModelSelection {
+    label: string;
+    available: boolean;
 }
-declare function ArtifactOpenProvider({ onOpenArtifact, children }: ArtifactOpenProviderProps): react_jsx_runtime.JSX.Element;
-declare function useOpenArtifact(): OpenArtifactHandler | null;
 
 /**
  * Suggested action shown in a chat empty state. Customizable per child app
@@ -142,28 +104,85 @@ interface ChatEmptyStateProps {
 }
 declare function ChatEmptyState({ eyebrow, title, description, suggestions, onSelect, footer, className, }: ChatEmptyStateProps): react_jsx_runtime.JSX.Element;
 
-/**
- * Selected model, stored as { provider, id } so the composer can pass through
- * the agent runtime's registered model IDs rather than a local alias table.
- * Unqualified legacy aliases are ignored: Boring must not infer a provider
- * when the runtime owns model selection.
- */
-interface ModelSelection {
-    provider: string;
-    id: string;
+interface ParsedCommand {
+    name: string;
+    args: string;
 }
+declare function parseSlashCommand(text: string): ParsedCommand | null;
 
-type ComposerBlockerAction = {
-    id: string;
-    label: string;
-};
-type ComposerBlocker = {
-    id: string;
-    reason: string;
-    label?: string;
-    sessionId?: string;
-    actions?: ComposerBlockerAction[];
+type SlashCommandHandlerResult = string | void | {
+    message?: string;
+    preserveDraft?: boolean;
 };
+type SlashCommandHandler = (args: string, ctx: SlashCommandContext) => SlashCommandHandlerResult | Promise<SlashCommandHandlerResult>;
+interface SlashCommand {
+    name: string;
+    description: string;
+    /** 'skill' commands are forwarded to the PI agent as `skill: <name>\n\n<args>` instead of running locally. */
+    kind?: 'local' | 'skill';
+    handler: SlashCommandHandler;
+}
+interface SlashCommandContext {
+    sessionId: string;
+    clearMessages: () => void;
+    resetSession: () => void;
+    listCommands: () => SlashCommand[];
+    reloadAgentPlugins: () => Promise<string>;
+    openModelPicker?: () => boolean | void;
+    selectComposerModel?: (query: string) => string | void;
+    openThinkingPicker?: () => boolean | void;
+    selectComposerThinking?: (query: string) => string | void;
+    /**
+     * Drives the PluginUpdateStatus banner above the composer. The `/reload`
+     * builtin prefers this over the inline-text path: it calls
+     * `pluginUpdate.run()` which (1) sets the banner to "running", (2)
+     * hits /api/v1/agent/reload, (3) transitions to "success" or "error"
+     * with diagnostics. Returns a short string ack for the assistant
+     * message bubble.
+     */
+    pluginUpdate?: {
+        run: () => Promise<string>;
+    };
+}
+interface CommandRegistry {
+    register(cmd: SlashCommand): void;
+    get(name: string): SlashCommand | undefined;
+    list(): SlashCommand[];
+}
+declare function createCommandRegistry(initial?: SlashCommand[]): CommandRegistry;
+
+declare const builtinCommands: SlashCommand[];
+
+type ToolState = 'input-streaming' | 'input-available' | 'approval-requested' | 'approval-responded' | 'output-available' | 'output-error' | 'output-denied' | 'aborted';
+
+type BoringToolCallPart = Extract<BoringChatPart, {
+    type: 'tool-call';
+}>;
+interface ToolRendererResolution {
+    key: string;
+    source: 'rendererId' | 'toolName' | 'fallback';
+    requestedRendererId?: string;
+}
+interface ToolPart {
+    /** Neutral render-model type. Legacy `tool-<name>` values are accepted at the renderer boundary. */
+    type: 'tool-call' | `tool-${string}` | 'dynamic-tool';
+    toolName: string;
+    /** Stable tool call id; for Pi-native BoringChatPart this is BoringChatPart.id. */
+    toolCallId: string;
+    state: ToolState;
+    input?: unknown;
+    output?: unknown;
+    errorText?: string;
+    ui?: ToolUiMetadata;
+    rendererResolution?: ToolRendererResolution;
+}
+type ToolRenderablePart = ToolPart | BoringToolCallPart | unknown;
+type ToolRenderer = (part: ToolPart) => ReactNode;
+type ToolRendererOverrides = Partial<Record<string, ToolRenderer>>;
+declare const defaultToolRenderers: Record<string, ToolRenderer>;
+declare function mergeToolRenderers(overrides?: ToolRendererOverrides): Record<string, ToolRenderer>;
+declare function resolveToolRenderer(toolNameOrPart: string | ToolPart, overrides?: ToolRendererOverrides): ToolRenderer;
+
 type ChatPanelRuntimeDependenciesWarmupStatus = {
     state: 'preparing' | 'ready' | 'failed';
     message?: string;
@@ -183,126 +202,360 @@ type ChatPanelWorkspaceWarmupStatus = {
     message?: string;
     runtimeDependencies?: ChatPanelRuntimeDependenciesWarmupStatus;
 };
-type ChatSubmitSource = 'composer' | 'suggestion';
+
+interface OptimisticUserMessage extends BoringChatMessage {
+    role: 'user';
+    clientNonce: string;
+    clientSeq?: number;
+    /**
+     * Id of the last committed message when this optimistic prompt was submitted.
+     * Used to position the placeholder by sequence rather than by wall-clock time,
+     * so client/server clock skew can't render a just-sent prompt above the
+     * previous reply.
+     */
+    afterMessageId?: string;
+}
+
+type PiChatConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
+
+interface PiChatRuntimeNotice {
+    id: string;
+    level: 'info' | 'warning' | 'error';
+    text: string;
+    dismissible?: boolean;
+}
+interface PiChatRetryNotice {
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+    errorMessage: string;
+}
+interface PiChatSeqGap {
+    expectedSeq: number;
+    actualSeq: number;
+    lastSeq: number;
+}
+interface PiChatHistoryState {
+    /** First cut renders full history; this explicit shape leaves room for paged windows later. */
+    mode: 'full';
+    messageCount: number;
+}
+interface PiChatState {
+    sessionId: string;
+    workspaceId?: string;
+    storageScope: string;
+    status: PiChatStatus;
+    turnId?: string;
+    lastSeq: number;
+    committedMessages: BoringChatMessage[];
+    streamingMessage?: BoringChatMessage;
+    streamingPreservedTextPartKeys?: Set<string>;
+    history: PiChatHistoryState;
+    queue: {
+        followUps: QueuedUserMessage[];
+    };
+    optimisticOutbox: Record<string, OptimisticUserMessage>;
+    pendingToolCallIds: Set<string>;
+    connection: {
+        state: PiChatConnectionState;
+        lastHeartbeatAt?: number;
+    };
+    error?: ChatError;
+    retryNotice?: PiChatRetryNotice;
+    notices: PiChatRuntimeNotice[];
+    hydrated: boolean;
+    needsResync?: PiChatSeqGap;
+}
+
+type PiChatStoreListener = () => void;
+interface PiChatStoreOptions {
+    scheduleNotify?: (notify: () => void) => unknown;
+    cancelNotify?: (handle: unknown) => void;
+}
+
+interface RemotePiSessionHeaders {
+    [key: string]: string | undefined;
+}
+interface RemotePiSessionOptions {
+    sessionId: string;
+    workspaceId?: string;
+    storageScope?: string;
+    apiBaseUrl?: string;
+    headers?: RemotePiSessionHeaders | (() => RemotePiSessionHeaders | Promise<RemotePiSessionHeaders>);
+    fetch?: typeof globalThis.fetch;
+    onEvent?: (event: PiChatEvent) => void;
+    storeOptions?: PiChatStoreOptions;
+    autoStart?: boolean;
+    reconnect?: {
+        baseMs?: number;
+        maxMs?: number;
+        jitterRatio?: number;
+        random?: () => number;
+    };
+    debug?: {
+        largeStateWarningBytes?: number;
+        largeStateWarningMessages?: number;
+        onWarning?: (warning: RemotePiSessionLargeStateWarning) => void;
+    };
+    setTimeoutFn?: typeof globalThis.setTimeout;
+    clearTimeoutFn?: typeof globalThis.clearTimeout;
+}
+interface RemotePiSessionLargeStateWarning {
+    type: 'large-state';
+    sessionId: string;
+    approxBytes: number;
+    messageCount: number;
+    thresholdBytes: number;
+    thresholdMessages: number;
+}
+interface RemotePiSessionDebugState {
+    sessionId: string;
+    lastSeq: number;
+    status: PiChatState['status'];
+    connection: PiChatState['connection']['state'];
+    lastHeartbeatAt?: number;
+    queue: {
+        followUps: number;
+        optimisticOutbox: number;
+        pendingToolCalls: number;
+    };
+    recentEventTypes: string[];
+    gapCount: number;
+    retryNotice?: PiChatState['retryNotice'];
+    largeStateWarning?: RemotePiSessionLargeStateWarning;
+    history: {
+        mode: 'full';
+        messageCount: number;
+        streamingMessageCount: 0 | 1;
+    };
+    disposed: boolean;
+    generation: number;
+    streamRunId: number;
+    reconnectAttempt: number;
+    hasReconnectTimer: boolean;
+    inflightFetches: number;
+}
+declare class RemotePiSession {
+    private readonly options;
+    private readonly store;
+    private readonly fetchImpl;
+    private readonly apiBaseUrl;
+    private readonly storageScope;
+    private readonly setTimeoutFn;
+    private readonly clearTimeoutFn;
+    private generation;
+    private streamRunId;
+    private reconnectAttempt;
+    private started;
+    private disposed;
+    private streamAbortController?;
+    private reconnectTimer?;
+    private readonly fetchControllers;
+    private readonly recentEventTypes;
+    private gapCount;
+    private largeStateWarning?;
+    constructor(options: RemotePiSessionOptions);
+    getState(): PiChatState;
+    getDebugState(): RemotePiSessionDebugState;
+    subscribe(listener: PiChatStoreListener): () => void;
+    start(cursor?: number): Promise<void>;
+    prompt(payload: PromptPayload): Promise<PromptReceipt>;
+    followUp(payload: FollowUpPayload): Promise<FollowUpReceipt>;
+    clearQueue(payload?: QueueClearPayload): Promise<QueueClearReceipt>;
+    interrupt(payload?: InterruptPayload): Promise<CommandReceipt>;
+    stop(payload?: StopPayload): Promise<StopReceipt>;
+    dispose(): void;
+    private hydrateAndConnect;
+    private connectEvents;
+    private runEventStream;
+    private rehydrateAfterStreamReset;
+    private scheduleReconnect;
+    private postCommand;
+    private rollbackOptimisticMessage;
+    private fetchJson;
+    private requestHeaders;
+    private stateUrl;
+    private sessionUrl;
+    private dispatchProtocolError;
+    private recordEventType;
+    private recordLargeStateWarning;
+    private clearReconnectTimer;
+    private abortEventStream;
+    private isGenerationActive;
+    private isStreamActive;
+}
+
+interface ActiveSessionStorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+interface ActiveSessionStorageOptions {
+    storageScope?: string;
+    storage?: ActiveSessionStorageLike;
+}
+declare function activeSessionStorageKey(storageScope?: string): string;
+declare function readActiveSessionId(options?: ActiveSessionStorageOptions): string | undefined;
+declare function writeActiveSessionId(sessionId: string | undefined, options?: ActiveSessionStorageOptions): void;
+declare function clearActiveSessionId(options?: ActiveSessionStorageOptions): void;
+
+interface PiSessionCreateInit {
+    title?: string;
+}
+interface PiSessionRefreshOptions {
+    background?: boolean;
+}
+interface UsePiSessionsOptions {
+    apiBaseUrl?: string;
+    sessionsApiPath?: string;
+    workspaceId?: string;
+    storageScope?: string;
+    requestHeaders?: Record<string, string | undefined>;
+    enabled?: boolean;
+    refreshKey?: unknown;
+    initialActiveSessionId?: string;
+    fetch?: typeof globalThis.fetch;
+    storage?: ActiveSessionStorageLike;
+    createRemoteSession?: (options: RemotePiSessionOptions) => RemotePiSession;
+    remoteSessionOptions?: Omit<Partial<RemotePiSessionOptions>, 'sessionId' | 'workspaceId' | 'storageScope' | 'apiBaseUrl' | 'headers' | 'fetch'>;
+    connectActiveSession?: boolean;
+    retry?: {
+        maxRetries?: number;
+        baseMs?: number;
+        maxMs?: number;
+    };
+}
+interface UsePiSessionsResult {
+    sessions: SessionSummary[];
+    activeSession: SessionSummary | undefined;
+    activeSessionId: string | undefined;
+    activePiSession: RemotePiSession | undefined;
+    dataStorageScope: string;
+    loading: boolean;
+    loadingMore: boolean;
+    hasMore: boolean;
+    error: Error | undefined;
+    refresh: (options?: PiSessionRefreshOptions) => Promise<void>;
+    create: (init?: PiSessionCreateInit) => Promise<SessionSummary>;
+    switch: (id: string) => void;
+    delete: (id: string) => Promise<void>;
+    loadMore: () => Promise<void>;
+    reset: () => void;
+}
+declare function usePiSessions(options?: UsePiSessionsOptions): UsePiSessionsResult;
+
+interface SessionListProps {
+    sessions: SessionSummary[];
+    activeId?: string;
+    loading?: boolean;
+    onSwitch?: (id: string) => void;
+    onCreate?: () => void;
+    onDelete?: (id: string) => void;
+    onLoadMore?: () => void;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onClose?: () => void;
+    className?: string;
+}
+declare function SessionList({ sessions, activeId, loading, onSwitch, onCreate, onDelete, onLoadMore, hasMore, loadingMore, onClose, className, }: SessionListProps): react_jsx_runtime.JSX.Element;
+declare const SessionBrowser: typeof SessionList;
+
+interface ComposerBlockerAction {
+    id: string;
+    label: string;
+}
+interface ComposerBlocker {
+    id: string;
+    reason?: string;
+    label?: string;
+    sessionId?: string;
+    actions?: ComposerBlockerAction[];
+    surfaceKind?: string;
+    target?: unknown;
+}
+
+type ChatSubmitSource = 'composer' | 'suggestion' | 'auto-submit';
 interface ChatSubmitContext {
     files: FileUIPart[];
     sessionId: string;
     source: ChatSubmitSource;
 }
-interface ChatPanelProps {
-    sessionId: string;
-    toolRenderers?: ToolRendererOverrides;
+interface ChatPanelEmptyState {
+    eyebrow?: string;
+    title?: string;
+    description?: string;
+}
+interface PiChatPanelProps {
+    /** Optional externally selected Pi session id. When provided, session navigation is owned by the host. */
+    sessionId?: string;
+    /** Alias kept for consumers that still pass the pre-cutover prop name. */
     extraCommands?: SlashCommand[];
-    /**
-     * App-level hot-reload toggle. When `false`, the `/reload` slash
-     * command is hidden from the picker and the `/help` listing, and the
-     * PluginUpdateStatus banner above the composer never renders.
-     * Production apps that don't expose live plugin editing should pass
-     * `false`. Defaults to `true`.
-     */
-    hotReloadEnabled?: boolean;
-    onSessionReset?: () => void | Promise<void>;
-    /**
-     * Render flush, without the outer canvas tint or the inner mx/my rounded
-     * card chrome. Use when embedding ChatPanel inside a parent that already
-     * provides its own card surface (e.g. workspace's ChatCenteredShell).
-     * Defaults to `true` (standalone chrome on).
-     */
+    apiBaseUrl?: string;
+    workspaceId?: string;
+    storageScope?: string;
+    requestHeaders?: Record<string, string | undefined>;
+    storage?: ActiveSessionStorageLike;
+    fetch?: typeof globalThis.fetch;
+    className?: string;
     chrome?: boolean;
-    /**
-     * Cards shown when the conversation is empty. Click → sendMessage with the
-     * suggestion's `prompt` (or `label` as fallback). Pass `[]` to hide the
-     * grid; omit to inherit `defaultChatSuggestions`. Customizable per child
-     * app — e.g. a data-app might offer "Build a chart from a CSV" instead.
-     */
-    suggestions?: ChatSuggestion[];
-    /** Custom empty-state text. Omit to use defaults. */
-    emptyState?: {
-        eyebrow?: string;
-        title?: string;
-        description?: string;
-    };
-    /**
-     * Render the extended-thinking selector in the composer footer (off / low
-     * / medium / high). When enabled, the selected level is persisted in
-     * localStorage and sent through to the agent on every turn. Default off
-     * — opt-in because not every host wants users tweaking model knobs, and
-     * thinking budget consumes more tokens.
-     */
-    thinkingControl?: boolean;
-    /**
-     * Model selected before any local user choice exists. Usually supplied by
-     * the host's /api/v1/agent/models payload, so deployment env can choose
-     * the default without rebuilding consumers.
-     */
-    defaultModel?: ModelSelection;
-    /**
-     * Tap into the SSE data stream. Called for every `onData` part the
-     * agent emits — host apps use this to bridge agent-driven file
-     * changes into their own UI plumbing (see
-     * `useAgentFileChangeBridge` in `@hachej/boring-workspace` for the
-     * canonical wire-up).
-     */
-    onData?: (part: unknown) => void;
-    /** Headers sent with chat and chat-history requests. */
-    requestHeaders?: Record<string, string>;
-    /** When false, skip initial chat history/stream resume requests until the user sends. */
-    hydrateMessages?: boolean;
-    /**
-     * Called with a file path when the user clicks the path label inside
-     * a read / write / edit tool card. Hosts (e.g. @hachej/boring-workspace)
-     * supply this to open the file in the surrounding workbench. Without
-     * it the path renders as plain text. Mounted via context so any
-     * future renderer can consume it without a prop drill.
-     */
-    onOpenArtifact?: OpenArtifactHandler;
-    /**
-     * Enable the admin debug drawer — system prompt, raw messages JSON, and
-     * session activity. Intended for development and ops; keep off in
-     * production consumer UIs. The drawer chunk is lazy-loaded so this prop
-     * is zero-cost when off.
-     */
     debug?: boolean;
-    /** Draft text restored into the composer on mount/update. */
+    showSessions?: boolean;
+    hotReloadEnabled?: boolean;
+    suggestions?: ChatSuggestion[];
+    emptyState?: ChatPanelEmptyState;
+    emptyPlacement?: 'default' | 'hero';
+    composerPlaceholder?: string;
     initialDraft?: string;
-    /** Auto-submit initialDraft once after it is restored. Defaults to false. */
     autoSubmitInitialDraft?: boolean;
-    /** Called after initialDraft is applied to the composer. */
     onDraftRestored?: () => void;
-    /** Called after an auto-submitted initial draft is accepted for sending. */
     onAutoSubmitInitialDraftAccepted?: () => void;
-    /** Called after an auto-submitted initial draft finishes its turn. */
     onAutoSubmitInitialDraftSettled?: () => void;
-    /**
-     * Runs before any agent/model/session-history network send. Return false to
-     * cancel submission and keep the draft in the composer.
-     */
-    onBeforeSubmit?: (draft: string, ctx: ChatSubmitContext) => false | void | Promise<false | void>;
-    /** Disable server-backed model/skill discovery for public/local-only shells. */
+    model?: ModelSelection | null;
+    defaultModel?: ModelSelection;
+    availableModels?: AvailableModel[];
+    thinkingLevel?: ThinkingLevel;
+    thinkingControl?: boolean;
     serverResourcesEnabled?: boolean;
-    /** Center the empty-state prompt/composer for public landing experiences. */
-    emptyPlacement?: 'default' | 'hero';
-    /** Placeholder shown in the composer textarea. */
-    composerPlaceholder?: string;
-    /** Current workspace warmup state. Preparing/failed states keep submits local so drafts are not lost. */
+    mentionedFiles?: string[] | (() => string[]);
+    commands?: SlashCommand[];
+    toolRenderers?: ToolRendererOverrides;
+    createRemoteSession?: (options: RemotePiSessionOptions) => RemotePiSession;
+    remoteSessionOptions?: UsePiSessionsOptions['remoteSessionOptions'];
+    hydrateMessages?: boolean;
     workspaceWarmupStatus?: ChatPanelWorkspaceWarmupStatus;
-    /** Generic host-provided blockers that prevent starting a new user turn. */
+    onSessionReset?: () => void | Promise<void>;
+    onBeforeSubmit?: (draft: string, context: ChatSubmitContext) => false | void | boolean | Promise<false | void | boolean>;
+    onReloadAgentPlugins?: () => Promise<string>;
+    onCommandResult?: (message: string) => void;
+    onComposerWarning?: (message: string) => void;
+    onMentionedFilesConsumed?: () => void;
+    onData?: (part: unknown) => void;
+    onOpenArtifact?: (path: string) => void;
     composerBlockers?: ComposerBlocker[];
-    /** Called when the user presses Stop in the composer. */
     onComposerStop?: () => void;
     onComposerBlockerAction?: (blocker: ComposerBlocker, action: string) => void;
-    className?: string;
 }
-declare function ChatPanel(props: ChatPanelProps): react_jsx_runtime.JSX.Element;
+declare function PiChatPanel({ sessionId, extraCommands, apiBaseUrl, workspaceId, storageScope, requestHeaders, storage, fetch, className, chrome, debug, showSessions, hotReloadEnabled, suggestions, emptyState, emptyPlacement, composerPlaceholder, initialDraft, autoSubmitInitialDraft, onDraftRestored, onAutoSubmitInitialDraftAccepted, onAutoSubmitInitialDraftSettled, model, defaultModel, availableModels, thinkingLevel, thinkingControl, serverResourcesEnabled, mentionedFiles, commands, toolRenderers, createRemoteSession, remoteSessionOptions, hydrateMessages, workspaceWarmupStatus, onSessionReset, onBeforeSubmit, onReloadAgentPlugins, onCommandResult, onComposerWarning, onMentionedFilesConsumed, onData, onOpenArtifact, composerBlockers, onComposerStop, onComposerBlockerAction, }: PiChatPanelProps): react_jsx_runtime.JSX.Element;
 
 interface DebugDrawerProps {
+    apiBaseUrl?: string;
+    fetch?: typeof globalThis.fetch;
     sessionId: string;
     messages: UIMessage[];
     requestHeaders?: Record<string, string>;
+    storageScope?: string;
     width: number;
     onWidthChange: (w: number) => void;
 }
-declare function DebugDrawer({ sessionId, messages, requestHeaders, width, onWidthChange }: DebugDrawerProps): react_jsx_runtime.JSX.Element;
+declare function DebugDrawer({ apiBaseUrl, fetch, sessionId, messages, requestHeaders, storageScope, width, onWidthChange }: DebugDrawerProps): react_jsx_runtime.JSX.Element;
+
+type OpenArtifactHandler = (path: string) => void;
+interface ArtifactOpenProviderProps {
+    onOpenArtifact?: OpenArtifactHandler;
+    children: ReactNode;
+}
+declare function ArtifactOpenProvider({ onOpenArtifact, children }: ArtifactOpenProviderProps): react_jsx_runtime.JSX.Element;
+declare function useOpenArtifact(): OpenArtifactHandler | null;
 
 interface AgentCommandContribution {
     id: string;
@@ -321,93 +574,17 @@ interface AgentCommandOptions {
 }
 declare function getAgentCommands(options?: AgentCommandOptions): AgentCommandContribution[];
 
-type UseAgentChatOptions = Pick<SendMessageInput, 'sessionId' | 'model' | 'thinkingLevel'> & {
-    onData?: (part: unknown) => void;
-    requestHeaders?: Record<string, string>;
-    persistMessages?: boolean;
-    hydrateMessages?: boolean;
-};
-declare function useAgentChat(opts: UseAgentChatOptions): {
-    messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[];
-    sendMessage: (message?: (Omit<UIMessage<unknown, ai.UIDataTypes, ai.UITools>, "role" | "id"> & {
-        id?: string | undefined;
-        role?: "system" | "user" | "assistant" | undefined;
-    } & {
-        text?: never;
-        files?: never;
-        messageId?: string;
-    }) | {
-        text: string;
-        files?: FileList | ai.FileUIPart[];
-        metadata?: unknown;
-        parts?: never;
-        messageId?: string;
-    } | {
-        files: FileList | ai.FileUIPart[];
-        metadata?: unknown;
-        parts?: never;
-        messageId?: string;
-    } | undefined, options?: ai.ChatRequestOptions | undefined) => Promise<void>;
-    stop: () => void;
-    status: ai.ChatStatus;
-    hydrated: boolean;
-    hydratingMessages: boolean;
-    id: string;
-    setMessages: (messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[] | ((messages: UIMessage<unknown, ai.UIDataTypes, ai.UITools>[]) => UIMessage<unknown, ai.UIDataTypes, ai.UITools>[])) => void;
-    error: Error | undefined;
-    regenerate: ({ messageId, ...options }?: {
-        messageId?: string;
-    } & ai.ChatRequestOptions) => Promise<void>;
-    resumeStream: (options?: ai.ChatRequestOptions) => Promise<void>;
-    addToolResult: ai.ChatAddToolOutputFunction<UIMessage<unknown, ai.UIDataTypes, ai.UITools>>;
-    addToolOutput: ai.ChatAddToolOutputFunction<UIMessage<unknown, ai.UIDataTypes, ai.UITools>>;
-    addToolApprovalResponse: ai.ChatAddToolApproveResponseFunction;
-    clearError: () => void;
-};
-
-interface UseSessionsOptions {
-    requestHeaders?: Record<string, string>;
-    storageKey?: string;
-    enabled?: boolean;
-    refreshKey?: unknown;
-    initialActiveSessionId?: string;
-}
-interface UseSessionsResult {
-    sessions: SessionSummary[];
-    activeSession: SessionSummary | undefined;
-    activeSessionId: string | undefined;
-    loading: boolean;
-    loadingMore: boolean;
-    hasMore: boolean;
-    error: Error | undefined;
-    create: (init?: {
-        title?: string;
-    }) => Promise<SessionSummary>;
-    switch: (id: string) => void;
-    delete: (id: string) => Promise<void>;
-    loadMore: () => Promise<void>;
-}
-declare function useSessions(opts?: UseSessionsOptions): UseSessionsResult;
-
-interface ParsedCommand {
-    name: string;
-    args: string;
-}
-declare function parseSlashCommand(text: string): ParsedCommand | null;
-
-declare const builtinCommands: SlashCommand[];
-
 declare function mergeShadcnToolRenderers(overrides?: ToolRendererOverrides): Record<string, ToolRenderer>;
 
 type GroupedToolEntry = {
-    part: UIMessage['parts'][number];
+    part: ToolRenderablePart;
     key: string;
 };
 interface ToolCallGroupProps {
     tools: GroupedToolEntry[];
     mergedToolRenderers: ToolRendererOverrides;
 }
-declare const ToolCallGroup: react.MemoExoticComponent<({ tools, mergedToolRenderers }: ToolCallGroupProps) => react_jsx_runtime.JSX.Element>;
+declare const ToolCallGroup: react.MemoExoticComponent<({ tools, mergedToolRenderers }: ToolCallGroupProps) => react_jsx_runtime.JSX.Element | null>;
 
 type MessageProps = HTMLAttributes<HTMLDivElement> & {
     from: UIMessage["role"];
@@ -440,8 +617,9 @@ type ReasoningProps = ComponentProps<typeof Collapsible> & {
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
     duration?: number;
+    autoClose?: boolean;
 };
-declare const Reasoning: react.MemoExoticComponent<({ className, isStreaming, open, defaultOpen, onOpenChange, duration: durationProp, children, ...props }: ReasoningProps) => react_jsx_runtime.JSX.Element>;
+declare const Reasoning: react.MemoExoticComponent<({ className, isStreaming, open, defaultOpen, onOpenChange, duration: durationProp, autoClose, children, ...props }: ReasoningProps) => react_jsx_runtime.JSX.Element>;
 type ReasoningTriggerProps = ComponentProps<typeof CollapsibleTrigger> & {
     getThinkingMessage?: (isStreaming: boolean, duration?: number) => ReactNode;
 };
@@ -458,8 +636,8 @@ type CodeBlockProps = HTMLAttributes<HTMLDivElement> & {
 };
 declare const CodeBlock: ({ code, language, showLineNumbers, className, children, ...props }: CodeBlockProps) => react_jsx_runtime.JSX.Element;
 
-type PromptInputFooterProps = Omit<ComponentProps<typeof InputGroupAddon>, "align">;
-declare const PromptInputFooter: ({ className, ...props }: PromptInputFooterProps) => react_jsx_runtime.JSX.Element;
+type PromptInputFooterProps = ComponentProps<typeof InputGroupAddon>;
+declare const PromptInputFooter: ({ align, className, ...props }: PromptInputFooterProps) => react_jsx_runtime.JSX.Element;
 
 interface PromptInputMessage {
     text: string;
@@ -494,4 +672,4 @@ declare const PromptInputSubmit: ({ className, variant, size, status, onStop, on
 
 declare function cn(...inputs: ClassValue[]): string;
 
-export { type AgentCommandContribution, type AgentCommandOptions, ArtifactOpenProvider, ChatEmptyState, type ChatEmptyStateProps, ChatPanel, type ChatPanelProps, type ChatSuggestion, CodeBlock, type CommandRegistry, Conversation, ConversationContent, ConversationScrollButton, DebugDrawer, type GroupedToolEntry, Message, MessageAction, MessageActions, MessageContent, MessageResponse, type OpenArtifactHandler, type ParsedCommand, PromptInput, PromptInputFooter, PromptInputSubmit, PromptInputTextarea, Reasoning, ReasoningContent, ReasoningTrigger, type SlashCommand, type SlashCommandContext, ToolCallGroup, type ToolPart, type ToolRenderer, type ToolRendererOverrides, type UploadFileOptions, type UploadFileResult, type UseAgentChatOptions, type UseSessionsOptions, type UseSessionsResult, builtinCommands, cn, createCommandRegistry, defaultChatSuggestions, defaultToolRenderers, getAgentCommands, mergeShadcnToolRenderers, mergeToolRenderers, parseSlashCommand, resolveToolRenderer, uploadFile, useAgentChat, useOpenArtifact, useSessions };
+export { type AgentCommandContribution, type AgentCommandOptions, ArtifactOpenProvider, ChatEmptyState, type ChatEmptyStateProps, PiChatPanel as ChatPanel, type PiChatPanelProps as ChatPanelProps, type ChatSuggestion, CodeBlock, type CommandRegistry, Conversation, ConversationContent, ConversationScrollButton, DebugDrawer, type GroupedToolEntry, Message, MessageAction, MessageActions, MessageContent, MessageResponse, type OpenArtifactHandler, type ParsedCommand, PiChatPanel, type PiChatPanelProps, SessionBrowser as PiSessionBrowser, type PiSessionCreateInit, SessionList as PiSessionList, PromptInput, PromptInputFooter, PromptInputSubmit, PromptInputTextarea, Reasoning, ReasoningContent, ReasoningTrigger, type SessionListProps, type SlashCommand, type SlashCommandContext, ToolCallGroup, type ToolPart, type ToolRenderer, type ToolRendererOverrides, type UploadFileOptions, type UploadFileResult, type UsePiSessionsOptions, type UsePiSessionsResult, activeSessionStorageKey, builtinCommands, clearActiveSessionId, cn, createCommandRegistry, defaultChatSuggestions, defaultToolRenderers, getAgentCommands, mergeShadcnToolRenderers, mergeToolRenderers, parseSlashCommand, readActiveSessionId, resolveToolRenderer, uploadFile, useOpenArtifact, usePiSessions, writeActiveSessionId };