@sayknow-cli/coding-agent 0.4.1 → 0.4.3

package/dist/types/modes/acp/acp-agent.d.ts

@@ -0,0 +1,249 @@
+import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type DeleteSessionRequest, type DeleteSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import { type AcpProviderRegistration, AcpSdkAdapter } from "../../sdk/acp";
+import type { AcpStartupOptions } from "./startup-options";
+export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
+type JsonObject = Record<string, unknown>;
+/** Applies ACP's offset cursor after narrowing the broker listing to the requested cwd. */
+export declare function paginateAcpSessions(listed: unknown[], cwd: string | undefined, offset: number): ListSessionsResponse;
+export type TranscriptReplayBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+};
+/**
+ * The production transcript query exposes durable `{ body, textSummary }`
+ * entries, not an ACP-shaped `content` array. Historical session JSONL has no
+ * recoverable image bytes, so replay exposes that boundary rather than
+ * pretending images were restored.
+ */
+export interface TranscriptReplayContent {
+    blocks: TranscriptReplayBlock[];
+    images: {
+        available: false;
+        reason: "historical_transcript_images_unavailable";
+    };
+}
+export declare function transcriptReplayContent(entry: unknown): TranscriptReplayContent;
+/** Maps live canonical SDK config and model queries into the ACP 1.2.1 session state surface. */
+export declare function acpSessionStateFromConfig(query: unknown, modelsQuery?: unknown): {
+    configOptions: ({
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+        id: "model";
+        name: "Model";
+    } | {
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+        id: "thinking";
+        name: "Thinking";
+    } | {
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+        id: "steeringMode";
+        name: "Steering queue";
+    } | {
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+        id: "followUpMode";
+        name: "Follow-up queue";
+    } | {
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+        id: "interruptMode";
+        name: "Interrupt mode";
+    } | {
+        id: string;
+        name: string;
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[];
+    })[];
+    modes: {
+        availableModes: {
+            id: string;
+            name: string;
+        }[];
+        currentModeId: string;
+    };
+};
+/** Convert every ACP prompt block the agent advertises without silently discarding context. */
+export declare function acpPromptPayload(blocks: PromptRequest["prompt"]): {
+    text: string;
+    images: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+};
+/** Registers a permission provider only when the ACP client requires prompts. */
+export declare function acpProviderRegistrations(capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): AcpProviderRegistration[];
+/** Maps ACP permission handling to the session's canonical SDK policy. */
+export declare function applyAcpPermissionMode(adapter: Pick<AcpSdkAdapter, "control">, capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Applies CLI-provided ACP startup settings through SDK controls before session exposure. */
+export declare function applyAcpStartupOptions(adapter: Pick<AcpSdkAdapter, "setModel" | "control">, options: AcpStartupOptions | undefined): Promise<void>;
+/** ACP form elicitation uses the client-facing reverse surface without owning a session runtime. */
+export declare function createAcpExtensionUiContext(connection: AgentSideConnection, getSessionId: () => string, capabilities: ClientCapabilities | undefined): {
+    select: (message: string, options: string[], dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<string | undefined>;
+    confirm: (message: string, detail?: string, dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<boolean>;
+    input: (message: string, placeholder?: string, dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<string | undefined>;
+};
+/**
+ * ACP is a pure SDK client. Session processes are created and resumed by the
+ * broker, while all per-session operations use that session's authenticated SDK
+ * endpoint. This class deliberately imports neither AgentSession nor any local
+ * runtime host component.
+ */
+export declare class AcpAgent implements Agent {
+    #private;
+    constructor(connection: AgentSideConnection, options?: {
+        agentDir?: string;
+        startupOptions?: AcpStartupOptions;
+    } | unknown);
+    initialize(params: InitializeRequest): Promise<InitializeResponse>;
+    authenticate(params: AuthenticateRequest): Promise<AuthenticateResponse>;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
+    unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
+    closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
+    deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse>;
+    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
+    setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: {
+        sessionId: string;
+    }): Promise<void>;
+    extMethod(method: string, params: JsonObject): Promise<JsonObject>;
+    extNotification(_method: string, _params: JsonObject): Promise<void>;
+    get signal(): AbortSignal;
+    get closed(): Promise<void>;
+}
+export {};

package/dist/types/modes/acp/acp-client-bridge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ACP-side `ClientBridge` implementation. Wraps `AgentSideConnection` so the
+ * `read`/`write`/`bash`/`monitor`/`edit` tools (and the permission gate in
+ * `AgentSession`) can route through the client when it advertises the
+ * relevant capabilities at `initialize` time.
+ */
+import type { AgentSideConnection, ClientCapabilities } from "@agentclientprotocol/sdk";
+import type { ClientBridge } from "../../session/client-bridge";
+export { type AcpPermissionMode, resolveAcpPermissionMode } from "./permission-mode";
+export declare function createAcpClientBridge(connection: AgentSideConnection, sessionId: string, clientCapabilities: ClientCapabilities | undefined): ClientBridge;

package/dist/types/modes/acp/acp-event-mapper.d.ts

@@ -0,0 +1,36 @@
+import type { SessionNotification, SessionUpdate, ToolKind } from "@agentclientprotocol/sdk";
+import type { AgentSessionEvent } from "../../session/agent-session";
+import type { AgentWireEventPayload } from "../shared/agent-wire/event-contract";
+interface MessageProgress {
+    textEmitted: boolean;
+    thoughtEmitted: boolean;
+}
+interface AcpEventMapperOptions {
+    getMessageId?: (message: unknown) => string | undefined;
+    getMessageProgress?: (message: unknown) => MessageProgress | undefined;
+    getToolArgs?: (toolCallId: string) => unknown;
+    /**
+     * Session cwd. Tool call locations sent to ACP clients must be absolute
+     * (the editor host needs them to open or focus files). When provided,
+     * the mapper resolves raw `path`/`file`/etc. args against this cwd
+     * before emitting `ToolCallLocation` entries.
+     */
+    cwd?: string;
+    /** Phase to expose after compaction ends. Prompt-bound compaction resumes responding; idle maintenance returns idle. */
+    compactionEndPhase?: "responding" | "idle";
+}
+export declare function mapToolKind(toolName: string): ToolKind;
+export declare function mapAgentWireEventPayloadToAcpSessionUpdates(payload: AgentWireEventPayload, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];
+export declare function mapAgentSessionEventToAcpSessionUpdates(event: AgentSessionEvent, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];
+export declare function buildToolCallStartUpdate(input: {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    intent?: string;
+    cwd?: string;
+    status?: "pending" | "completed";
+}): SessionUpdate;
+export declare function normalizeReplayToolArguments(value: unknown): {
+    args: unknown;
+};
+export {};

package/dist/types/modes/acp/acp-mode.d.ts

@@ -0,0 +1,8 @@
+import { AgentSideConnection, type Stream } from "@agentclientprotocol/sdk";
+import type { AcpStartupOptions } from "./startup-options";
+export interface AcpModeOptions {
+    agentDir?: string;
+    startupOptions?: AcpStartupOptions;
+}
+export declare function createAcpConnection(transport: Stream, options?: AcpModeOptions): AgentSideConnection;
+export declare function runAcpMode(options?: AcpModeOptions): Promise<never>;

package/dist/types/modes/acp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./acp-agent";
+export * from "./acp-mode";

package/dist/types/modes/acp/permission-mode.d.ts

@@ -0,0 +1,4 @@
+import type { ClientCapabilities } from "@agentclientprotocol/sdk";
+export type AcpPermissionMode = "auto" | "prompt" | "always-allow";
+/** Client metadata is authoritative; the process environment is only a fallback when that field is absent. */
+export declare function resolveAcpPermissionMode(clientCapabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): AcpPermissionMode;

package/dist/types/modes/acp/startup-options.d.ts

@@ -0,0 +1,6 @@
+/** Startup settings that ACP can apply through the canonical SDK control surface. */
+export interface AcpStartupOptions {
+    modelId?: string;
+    modelPreset?: string;
+    thinkingLevel?: string;
+}

package/dist/types/modes/acp/terminal-auth.d.ts

@@ -0,0 +1,6 @@
+export declare const ACP_TERMINAL_AUTH_FLAG = "--acp-terminal-auth";
+export interface AcpTerminalAuthArgs {
+    args: string[];
+    terminalAuth: boolean;
+}
+export declare function prepareAcpTerminalAuthArgs(rawArgs: readonly string[]): AcpTerminalAuthArgs;

package/dist/types/modes/action-registry.d.ts

@@ -0,0 +1,29 @@
+import type { AppKeybinding } from "../config/keybindings";
+export type FocusDomain = "composer" | "selector" | "overlay" | "global";
+export interface ActionMetadata {
+    id: AppKeybinding;
+    title: string;
+    category: string;
+    bindingId?: AppKeybinding;
+    domains: readonly FocusDomain[];
+    exclusiveGroup?: string | false;
+}
+export declare const APP_ACTION_METADATA: readonly ActionMetadata[];
+export interface ActionDefinition<Context> extends ActionMetadata {
+    availability(context: Context): boolean;
+    execute(context: Context): void | Promise<void>;
+}
+export interface ActionRegistryOptions<Context> {
+    context: Context;
+    showError(error: string): void;
+}
+export declare class ActionRegistry<Context> {
+    #private;
+    private readonly options;
+    constructor(options: ActionRegistryOptions<Context>);
+    register(action: ActionDefinition<Context>): void;
+    get(id: AppKeybinding): ActionDefinition<Context> | undefined;
+    all(): readonly ActionDefinition<Context>[];
+    isAvailable(id: AppKeybinding): boolean;
+    execute(id: AppKeybinding): Promise<boolean>;
+}

package/dist/types/modes/bridge/auth.d.ts

@@ -0,0 +1,12 @@
+export interface BridgeAuthConfig {
+    token: string;
+}
+export interface BridgeBindConfig {
+    hostname: string;
+    port: number;
+    tlsConfigured: boolean;
+}
+export declare function extractBearerToken(authorization: string | null | undefined): string | undefined;
+export declare function isBridgeTokenAuthorized(authorization: string | null | undefined, config: BridgeAuthConfig): boolean;
+export declare function isLoopbackHost(hostname: string): boolean;
+export declare function assertSafeBridgeBind(config: BridgeBindConfig): void;

package/dist/types/modes/bridge/bridge-client-bridge.d.ts

@@ -0,0 +1,9 @@
+import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
+import type { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+export interface BridgePermissionRequestPayload {
+    kind: "permission";
+    toolCall: ClientBridgePermissionToolCall;
+    options: ClientBridgePermissionOption[];
+}
+export type BridgePermissionBroker = UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+export declare function createBridgeClientBridge(broker: BridgePermissionBroker): ClientBridge;

package/dist/types/modes/bridge/bridge-mode.d.ts

@@ -0,0 +1,47 @@
+import type { ExtensionUIContext } from "../../extensibility/extensions";
+import type { AgentSession } from "../../session/agent-session";
+import type { ClientBridgePermissionOutcome } from "../../session/client-bridge";
+import type { RpcCommand, RpcResponse } from "../rpc/rpc-types";
+import { RpcHostToolBridge } from "../shared/agent-wire/host-tool-bridge";
+import { RpcHostUriBridge } from "../shared/agent-wire/host-uri-bridge";
+import { type BridgeCommandScope } from "../shared/agent-wire/scopes";
+import { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
+import { type BridgePermissionRequestPayload } from "./bridge-client-bridge";
+import { type BridgeUiRequestPayload } from "./bridge-ui-context";
+import { BridgeEventStream } from "./event-stream";
+interface BridgeEndpointMatrix {
+    events: boolean;
+    commands: boolean;
+    control: boolean;
+    uiResponses: boolean;
+    hostToolResults: boolean;
+    hostUriResults: boolean;
+}
+interface BridgeFetchHandlerOptions {
+    sessionId: string;
+    token: string;
+    eventStream?: BridgeEventStream;
+    commandDispatcher?: (command: RpcCommand) => Promise<RpcResponse>;
+    commandScopes?: readonly BridgeCommandScope[];
+    idempotencyCache?: BridgeIdempotencyCache;
+    permissionBroker?: UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+    uiBroker?: UiRequestBroker<BridgeUiRequestPayload, BridgeUiResult<unknown>>;
+    hostToolBridge?: RpcHostToolBridge;
+    hostUriBridge?: RpcHostUriBridge;
+    endpointMatrix?: Partial<BridgeEndpointMatrix>;
+    unattendedControlPlane?: UnattendedSessionControlPlane;
+}
+interface BridgeIdempotencyRecord {
+    route: string;
+    ownerToken?: string;
+    body: string | Promise<string>;
+    response: unknown | Promise<unknown>;
+    pending?: boolean;
+}
+type BridgeIdempotencyCache = Map<string, BridgeIdempotencyRecord>;
+export declare function parseBridgeEndpoints(value: string | undefined): Partial<BridgeEndpointMatrix> | undefined;
+export declare function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (request: Request) => Promise<Response>;
+export declare function runBridgeMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export {};

package/dist/types/modes/bridge/bridge-ui-context.d.ts

@@ -0,0 +1,88 @@
+import type { ExtensionUIContext, ExtensionUIDialogOptions, ExtensionWidgetContent, ExtensionWidgetOptions, TerminalInputHandler } from "../../extensibility/extensions";
+import type { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { type Theme } from "../theme/theme";
+export type BridgeUiRequestPayload = {
+    kind: "select";
+    title: string;
+    options: string[];
+    timeout?: number;
+} | {
+    kind: "confirm";
+    title: string;
+    message: string;
+    timeout?: number;
+} | {
+    kind: "input";
+    title: string;
+    placeholder?: string;
+    timeout?: number;
+} | {
+    kind: "editor";
+    title: string;
+    prefill?: string;
+    promptStyle?: boolean;
+} | {
+    kind: "notify";
+    message: string;
+    type?: "info" | "warning" | "error";
+} | {
+    kind: "status";
+    key: string;
+    text: string | undefined;
+} | {
+    kind: "widget";
+    key: string;
+    lines: string[] | undefined;
+    placement?: "aboveEditor" | "belowEditor";
+} | {
+    kind: "title";
+    title: string;
+} | {
+    kind: "set_editor_text";
+    text: string;
+} | {
+    kind: "unsupported";
+    capability: string;
+    reason: string;
+};
+export type BridgeUiBroker = UiRequestBroker<BridgeUiRequestPayload, BridgeUiResult<unknown>>;
+export type BridgeUiEmitter = (payload: BridgeUiRequestPayload) => void;
+export declare class BridgeExtensionUIContext implements ExtensionUIContext {
+    #private;
+    constructor(options: {
+        broker: BridgeUiBroker;
+        emit: BridgeUiEmitter;
+    });
+    select(title: string, options: string[], dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    confirm(title: string, message: string, dialogOptions?: ExtensionUIDialogOptions): Promise<boolean>;
+    input(title: string, placeholder?: string, dialogOptions?: ExtensionUIDialogOptions): Promise<string | undefined>;
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+    onTerminalInput(_handler: TerminalInputHandler): () => void;
+    setStatus(key: string, text: string | undefined): void;
+    setWorkingMessage(message?: string): void;
+    setWidget(key: string, content: ExtensionWidgetContent, options?: ExtensionWidgetOptions): void;
+    setFooter(_factory?: unknown): void;
+    setHeader(_factory?: unknown): void;
+    setTitle(title: string): void;
+    custom<T>(): Promise<T>;
+    setEditorText(text: string): void;
+    pasteToEditor(text: string): void;
+    getEditorText(): string;
+    editor(title: string, prefill?: string, dialogOptions?: ExtensionUIDialogOptions, editorOptions?: {
+        promptStyle?: boolean;
+    }): Promise<string | undefined>;
+    setEditorComponent(_factory?: unknown): void;
+    get theme(): Theme;
+    getAllThemes(): Promise<{
+        name: string;
+        path: string | undefined;
+    }[]>;
+    getTheme(_name: string): Promise<Theme | undefined>;
+    setTheme(_theme: string | Theme): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getToolsExpanded(): boolean;
+    setToolsExpanded(_expanded: boolean): void;
+}

package/dist/types/modes/bridge/event-stream.d.ts

@@ -0,0 +1,8 @@
+import type { BridgeFrameEnvelope } from "../shared/agent-wire/protocol";
+export declare class BridgeEventStream {
+    #private;
+    constructor(replayLimit?: number);
+    get frameCount(): number;
+    publish(frame: BridgeFrameEnvelope): void;
+    response(lastSeq?: number): Response;
+}

package/dist/types/modes/components/agent-dashboard.d.ts

@@ -0,0 +1,24 @@
+import { Container } from "@sayknow-cli/tui";
+import type { ModelRegistry } from "../../config/model-registry";
+import { type ModelSelectorValue } from "../../config/model-selector-value";
+import { Settings } from "../../config/settings";
+interface AgentDashboardModelContext {
+    modelRegistry?: ModelRegistry;
+    activeModelPattern?: string;
+    defaultModelPattern?: string;
+}
+export declare function resolveAgentCreationModel(modelPatterns: string[], modelRegistry: ModelRegistry, settings: Settings | undefined): import("@sayknow-cli/ai").Model<import("@sayknow-cli/ai").Api>;
+export declare function updateAgentModelOverride(overrides: Record<string, ModelSelectorValue>, agentName: string, rawValue: string): Record<string, ModelSelectorValue>;
+export declare class AgentDashboard extends Container {
+    #private;
+    private readonly cwd;
+    private readonly settings;
+    private readonly terminalHeight;
+    private readonly modelContext;
+    onClose?: () => void;
+    onRequestRender?: () => void;
+    private constructor();
+    static create(cwd: string, settings?: Settings | null, terminalHeight?: number, modelContext?: AgentDashboardModelContext): Promise<AgentDashboard>;
+    handleInput(data: string): void;
+}
+export {};

package/dist/types/modes/components/ansi-display-validator.d.ts

@@ -0,0 +1,2 @@
+/** Removes every terminal control sequence except bounded SGR parameters (0-255). */
+export declare function validateDisplayLine(line: string): string;

package/dist/types/modes/components/assistant-message.d.ts

@@ -0,0 +1,20 @@
+import type { AssistantMessage, ImageContent, Usage } from "@sayknow-cli/ai";
+import { Container } from "@sayknow-cli/tui";
+interface AssistantMessageUpdateOptions {
+    streaming?: boolean;
+}
+/**
+ * Component that renders a complete assistant message
+ */
+export declare class AssistantMessageComponent extends Container {
+    #private;
+    private hideThinkingBlock;
+    private readonly onImageUpdate?;
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: (() => void) | undefined, viewportAnchorId?: string);
+    invalidate(): void;
+    setHideThinkingBlock(hide: boolean): void;
+    setToolResultImages(toolCallId: string, images: ImageContent[]): void;
+    setUsageInfo(usage: Usage): void;
+    updateContent(message: AssistantMessage, options?: AssistantMessageUpdateOptions): void;
+}
+export {};

package/dist/types/modes/components/bash-execution.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Component for displaying bash command execution with streaming output.
+ */
+import { Container, type TUI } from "@sayknow-cli/tui";
+import type { TruncationMeta } from "../../tools/output-meta";
+export declare class BashExecutionComponent extends Container {
+    #private;
+    private readonly command;
+    constructor(command: string, ui: TUI, excludeFromContext?: boolean);
+    /**
+     * Set whether the output is expanded (shows full output) or collapsed (preview only).
+     */
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    appendOutput(chunk: string): void;
+    setComplete(exitCode: number | undefined, cancelled: boolean, options?: {
+        output?: string;
+        truncation?: TruncationMeta;
+    }): void;
+    render(width: number): string[];
+    /**
+     * Get the raw output for creating BashExecutionMessage.
+     */
+    getOutput(): string;
+    /**
+     * Get the command that was executed.
+     */
+    getCommand(): string;
+}

package/dist/types/modes/components/bordered-loader.d.ts

@@ -0,0 +1,11 @@
+import { Container, type TUI } from "@sayknow-cli/tui";
+import type { Theme } from "../../modes/theme/theme";
+/** Loader wrapped with borders for hook UI */
+export declare class BorderedLoader extends Container {
+    #private;
+    constructor(tui: TUI, theme: Theme, message: string);
+    get signal(): AbortSignal;
+    set onAbort(fn: (() => void) | undefined);
+    handleInput(data: string): void;
+    dispose(): void;
+}

package/dist/types/modes/components/branch-summary-message.d.ts

@@ -0,0 +1,13 @@
+import { Box } from "@sayknow-cli/tui";
+import type { BranchSummaryMessage } from "../../session/messages";
+/**
+ * Component that renders a branch summary message with collapsed/expanded state.
+ * Uses same background color as hook messages for visual consistency.
+ */
+export declare class BranchSummaryMessageComponent extends Box {
+    #private;
+    private readonly message;
+    constructor(message: BranchSummaryMessage);
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+}

package/dist/types/modes/components/btw-panel.d.ts

@@ -0,0 +1,16 @@
+import { Container, type TUI } from "@sayknow-cli/tui";
+interface BtwPanelComponentOptions {
+    question: string;
+    tui: TUI;
+}
+export declare class BtwPanelComponent extends Container {
+    #private;
+    constructor(options: BtwPanelComponentOptions);
+    appendText(delta: string): void;
+    setAnswer(text: string): void;
+    markComplete(): void;
+    markAborted(): void;
+    markError(message: string): void;
+    close(): void;
+}
+export {};