@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/dist/types/chat/assistant-message.d.ts

@@ -0,0 +1,106 @@
+import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
+import { type Component, Container } from "../tui.js";
+import { type ImageBudget } from "../components/image.js";
+import type { AssistantThinkingRenderer } from "./extension-types.js";
+import { type CacheInvalidation } from "./cache-invalidation-marker.js";
+import { type ServedModelMismatch } from "./served-model-marker.js";
+import { type TranscriptStableRow } from "../chrome/transcript-container.js";
+/** Test-only: clear the shared gauge so observations don't leak across cases. */
+export declare function resetThinkingSpeedTracker(): void;
+/**
+ * Renders an assistant message; streaming content remains mutable until the
+ * provider finalizes it because later deltas can revise earlier Markdown.
+ * The exception is the leading run of visible thinking blocks: raw thinking
+ * only ever appends, so its frozen Markdown prefix publishes as append-only
+ * stable rows ({@link AppendOnlyTranscriptBlock}) and can retire into native
+ * scrollback while the block still streams — a long reasoning trace is no
+ * longer clipped to the mutable viewport.
+ */
+export declare class AssistantMessageComponent extends Container {
+    #private;
+    readonly transcriptBlockMode: "appendOnly";
+    setTextColorTransform(transform?: (text: string) => string): void;
+    /**
+     * Install resolved destinations for model-authored prose links. A fresh
+     * theme object is required whenever the map changes because Markdown's
+     * render cache keys themes by object identity.
+     */
+    setLinkTargets(targets: ReadonlyMap<string, string>): void;
+    /**
+     * Choose the block this reply reacts to from the transcript it is about to
+     * join: the nearest preceding reaction-capable block (the user's bubble),
+     * looking past turn attachments such as file mentions or injected notices
+     * but never past an earlier reply — a continuation after tool calls has
+     * nothing to react to. Call before adding this component. An
+     * already-resolved reaction is re-applied, and a message rendered verbatim
+     * for lack of a target is re-rendered with its reaction stripped.
+     */
+    pickReactionTarget(transcript: readonly Component[]): void;
+    constructor(message?: AssistantMessage, hideThinkingBlock?: boolean, onImageUpdate?: () => void, thinkingRenderers?: readonly AssistantThinkingRenderer[], imageBudget?: ImageBudget, proseOnlyThinking?: boolean, linkTargets?: ReadonlyMap<string, string>);
+    /**
+     * Show or clear the trailing cache-invalidation divider. Set at `message_end`
+     * (live) or during rebuild, once the turn's usage is known and compared
+     * against the previous turn's cache footprint.
+     */
+    setCacheInvalidation(info: CacheInvalidation | undefined): void;
+    /**
+     * Show or clear the trailing served-model divider. Set once the turn's
+     * signed thinking block (or router report) has named the model that actually
+     * answered, when it differs from the one requested.
+     */
+    setServedModelMismatch(info: ServedModelMismatch | undefined): void;
+    invalidate(): void;
+    setHideThinkingBlock(hide: boolean): void;
+    /**
+     * Allow or withhold retiring finished lines into native scrollback while the
+     * turn is still streaming. Wires the `stream-revision` axis marks as able to
+     * revise already-streamed text must withhold it: published bytes go to
+     * terminal history once and cannot be retracted, so a later revision would
+     * leave the reader with a stale copy. Withholding costs only reachability —
+     * the block still retires whole when the turn ends.
+     */
+    setMidStreamPublication(allowed: boolean): void;
+    setProseOnlyThinking(proseOnly: boolean): void;
+    dispose(): void;
+    /**
+     * Toggle suppression of the inline `Error: …` line while the same error is
+     * pinned in the banner above the editor. Re-renders so the change is visible.
+     */
+    setErrorPinned(pinned: boolean): void;
+    /**
+     * Expand or collapse the inline turn-ending error block so Ctrl+O
+     * (tool-output expansion) can reveal a long provider error's hidden tail.
+     * Only re-renders when the current message carries a truncatable error, so
+     * toggling expansion across the transcript skips ordinary turns. Works even
+     * while the error is pinned in the banner: the inline block is drawn (in full)
+     * when expanded so the complete body is reachable without sending a message.
+     */
+    setExpanded(expanded: boolean): void;
+    isTranscriptBlockFinalized(): boolean;
+    render(width: number): readonly string[];
+    /** Width-independent stable identities for the streamed leading thinking run. */
+    getTranscriptStableRows(): readonly TranscriptStableRow[];
+    /**
+     * Drop every published thinking stable row. Called by the transcript
+     * container during a visibility-driven destructive replay so the head no
+     * longer re-emits reasoning captured while thinking was visible. Safe only
+     * because the paired display reset clears the scrollback those rows occupied
+     * — see {@link AppendOnlyTranscriptBlock.resetTranscriptStableRows}.
+     */
+    resetTranscriptStableRows(): void;
+    renderTranscriptStableRows(count: number, width: number): readonly string[];
+    /** Render completed prose rather than an earlier thinking row under emergency viewport pressure. */
+    renderTranscriptBlockEmergencyRow(width: number): string | undefined;
+    getTranscriptBlockVersion(): number;
+    markTranscriptBlockFinalized(): void;
+    applyRetryRecovery(retryRecovery: AssistantMessage["retryRecovery"]): void;
+    messagePersistenceKey(): string | undefined;
+    /** Toggle rendering for assistant-native and tool-result images. */
+    setImagesVisible(visible: boolean): void;
+    /** Toggle only images produced by tool results; assistant-native images remain governed by setImagesVisible. */
+    setToolResultImagesVisible(visible: boolean): void;
+    setToolResultImages(toolCallId: string, images: ImageContent[]): void;
+    updateContent(message: AssistantMessage, opts?: {
+        transient?: boolean;
+    }): void;
+}

package/dist/types/chat/background-tan-message.d.ts

@@ -0,0 +1,9 @@
+import type { CustomMessage } from "./messages.js";
+import type { TranscriptBlock } from "../chrome/transcript-container.js";
+/**
+ * Single-line transcript pill for a `/tan` background-dispatch breadcrumb,
+ * styled as a sibling of the "Background job completed" line. The full
+ * system-notice content (the persisted `content`) is for the model only — the
+ * user sees one compact line, not the raw `<system-notice>` block.
+ */
+export declare function createBackgroundTanDispatchBlock(message: CustomMessage<unknown>): TranscriptBlock;

package/dist/types/chat/bash-execution.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Component for displaying bash command execution with streaming output.
+ */
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { Container, type TUI } from "../tui.js";
+import type { OutputArtifactError } from "../tools/streaming-output.js";
+import type { TruncationMeta } from "../tools/output-meta.js";
+/** PTY size for `!` commands: the execution frame's inner content area. */
+export declare function bashPtyViewport(ui: TUI): {
+    cols: number;
+    rows: number;
+};
+export declare class BashExecutionComponent extends Container {
+    #private;
+    constructor(command: string, ui: TUI, excludeFromContext?: boolean);
+    /**
+     * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+     * streaming preview rewrites its tail window every chunk, so the block must
+     * stay out of native scrollback until the command completes.
+     */
+    isTranscriptBlockFinalized(): boolean;
+    getTranscriptBlockVersion(): number;
+    /**
+     * Set whether the output is expanded (shows full output) or collapsed (preview only).
+     */
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    appendOutput(chunk: string): void;
+    /** Switch to PTY rendering and feed raw terminal bytes through the vterm replay. */
+    appendPtyChunk(chunk: string): void;
+    setComplete(exitCode: number | undefined, cancelled: boolean, options?: {
+        output?: string;
+        truncation?: TruncationMeta;
+        artifactError?: OutputArtifactError;
+        images?: readonly ImageContent[];
+        showImages?: boolean;
+    }): void;
+    render(width: number): readonly string[];
+    /**
+     * Get the raw output for creating BashExecutionMessage.
+     */
+    getOutput(): string;
+    /**
+     * Get the command that was executed.
+     */
+    getCommand(): string;
+}

package/dist/types/chat/cache-invalidation-marker.d.ts

@@ -0,0 +1,50 @@
+import type { Usage } from "@oh-my-pi/pi-ai";
+import { MessageDividerComponent } from "../chrome/message-divider.js";
+/** A prompt-cache invalidation detected from a turn's usage. */
+export interface CacheInvalidation {
+    /** Prompt tokens the cold turn had to (re)process instead of reading from cache. */
+    reprocessedTokens: number;
+}
+/**
+ * Decide whether `current` turn lost a *working* prompt cache that `prev` was
+ * reusing.
+ *
+ * The provider reports a warm prefix as `cacheRead`; a model/thinking/tool/
+ * system-prompt change (or a history rewrite) breaks the prefix, so the next
+ * request reads nothing from cache and re-pays for the whole prompt. We flag
+ * only the transition where a demonstrably warm cache goes cold: the previous
+ * turn must have actually READ a meaningful prefix back, and this turn's
+ * `cacheRead` collapsed to zero while it still reprocessed a non-trivial prompt.
+ *
+ * Requiring a prior warm read is deliberate. A turn that merely WROTE the prefix
+ * (`cacheRead` 0) has not proven the cache is live — that is the session's first
+ * request, or a re-write after expiry — so a following cold turn there is
+ * expected, not an invalidation the user caused (e.g. a long-running first tool
+ * call outliving the provider's 5-minute cache TTL surfaced a spurious "cache
+ * miss" right under the opening message). It also collapses a run of consecutive
+ * cold turns to the single marker at the moment the cache actually broke, instead
+ * of repeating the banner on every turn while it re-warms.
+ *
+ * Returns `undefined` (no marker) for the first turn, turns whose predecessor
+ * never read a warm prefix, tiny contexts, turns that reused any cache, and —
+ * crucially — turns on providers with *implicit* best-effort caching. Only an
+ * explicit, prefix-controlled cache (Anthropic / Bedrock `cache_control`)
+ * re-creates the prefix on a cold turn (`cacheWrite > 0`); implicit caches
+ * (Google / OpenAI / Fireworks) report `cacheWrite: 0` and drop `cacheRead` to
+ * zero intermittently as routine propagation noise that self-heals the next
+ * turn, so flagging it would be a false positive.
+ */
+export declare function detectCacheInvalidation(prev: Usage | undefined, current: Usage): CacheInvalidation | undefined;
+/**
+ * Slim left-aligned divider rendered after an assistant turn whose request lost
+ * the prompt cache. It trails streamed content because usage arrives at message
+ * end, after completed rows may already be in native history.
+ *
+ * Mirrors the compaction divider's banner styling but spans only a short rule
+ * plus label (not the full width) and carries no expandable detail:
+ *
+ *   ────────── ⊘ cache miss · 50.9k tokens
+ */
+export declare class CacheInvalidationMarkerComponent extends MessageDividerComponent {
+    constructor(info: CacheInvalidation);
+}

package/dist/types/chat/chat-transcript-builder.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Builds transcript components from persisted session message entries — the
+ * file/remote-backed counterpart to {@link UiHelpers.addMessageToChat} (which is
+ * bound to the live InteractiveModeContext). Used by the fullscreen transcript
+ * viewer ({@link AgentTranscriptViewer}) to render a parked subagent / advisor /
+ * collab-guest transcript that has no live session.
+ *
+ * Unlike the old incremental hub sync, {@link ChatTranscriptBuilder.rebuild}
+ * always discards prior components and rebuilds the whole transcript from the
+ * supplied entries. Re-rendering a growing transcript is therefore O(n) in the
+ * entry count, but it cannot duplicate or misorder rows the way incremental
+ * component reuse could.
+ */
+import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import { type TUI } from "../tui.js";
+import type { MessageRenderer } from "./extension-types.js";
+import { type TranscriptEntryLike as TranscriptEntry } from "./transcript-entry.js";
+import { TranscriptContainer } from "../chrome/transcript-container.js";
+export interface ChatTranscriptBuilderDeps {
+    ui: TUI;
+    getTool?: (name: string) => AgentTool | undefined;
+    /** Whether the active registry entry came from a built-in factory. */
+    isBuiltInTool?: (name: string) => boolean;
+    getMessageRenderer?: (customType: string) => MessageRenderer | undefined;
+    cwd: string;
+    hideThinkingBlock?: () => boolean;
+    proseOnlyThinking?: () => boolean;
+    /** Session-scoped resolved destinations for model-authored Markdown links. */
+    linkTargets?: ReadonlyMap<string, string>;
+    requestRender: () => void;
+}
+export declare class ChatTranscriptBuilder {
+    #private;
+    readonly container: TranscriptContainer;
+    constructor(deps: ChatTranscriptBuilderDeps);
+    /** Whether the transcript currently holds any rendered rows. */
+    get isEmpty(): boolean;
+    /** Discard all components and rebuild the whole transcript from `entries`. */
+    rebuild(entries: TranscriptEntry[]): void;
+    /** Append newly persisted entries without rebuilding already rendered rows. */
+    append(entries: TranscriptEntry[]): void;
+    /** Toggle tool-output expansion across every expandable component. */
+    setExpanded(expanded: boolean): void;
+    get expanded(): boolean;
+    /** Rendered row where a persisted entry begins, after the container has painted once. */
+    rowForEntry(entryId: string): number | undefined;
+    /** Tear down components (sealing pending spinners) and clear build state. */
+    reset(): void;
+    dispose(): void;
+}

package/dist/types/chat/collab-prompt-message.d.ts

@@ -0,0 +1,10 @@
+import { Container } from "../tui.js";
+import type { CollabPromptDetails } from "./messages.js";
+import type { CustomMessage } from "./messages.js";
+/**
+ * Renders a collab guest prompt on every participant's transcript: a
+ * user-message-styled bubble prefixed with the author's name.
+ */
+export declare class CollabPromptMessageComponent extends Container {
+    constructor(message: CustomMessage<CollabPromptDetails>);
+}

package/dist/types/chat/compaction-summary-message.d.ts

@@ -0,0 +1,54 @@
+import { type Component } from "../tui.js";
+import type { BranchSummaryMessage, CompactionSummaryMessage, CustomMessage } from "./messages.js";
+interface SummaryDividerOptions {
+    label: () => string;
+    detailMarkdown: () => string;
+}
+/**
+ * Common summary/detail delegate behind the compaction, handoff, and branch
+ * banners: the width-aware divider is always shown while the Markdown detail
+ * box is constructed lazily only on the first expanded render and retained
+ * across collapse/re-expand cycles.
+ */
+declare class SummaryMessageComponent implements Component {
+    #private;
+    constructor(options: SummaryDividerOptions);
+    setExpanded(expanded: boolean): void;
+    setIgnoreTight(ignore: boolean): this;
+    invalidate(): void;
+    dispose(): void;
+    render(width: number): readonly string[];
+}
+/**
+ * Compaction point in the transcript, rendered as a slim horizontal divider:
+ *
+ *   ──────── 📷 remote-compacted · 256K→20K · ctrl+o ────────
+ *
+ * The label names the maintenance method that fired (remote/soft/handoff/
+ * snapcompact; "compacted" for legacy or extension-provided entries) and the
+ * before → after context amounts when the entry recorded them. The
+ * conversation above the divider stays visible (display transcript keeps
+ * full history); only the LLM context was reset. Expanding (ctrl+o) reveals
+ * the compaction summary below the divider.
+ */
+export declare class CompactionSummaryMessageComponent extends SummaryMessageComponent {
+    constructor(message: CompactionSummaryMessage);
+}
+/**
+ * Handoff is a compaction strategy too, but it is persisted as a custom message
+ * so the LLM sees the handoff-specific developer context. Render it with the
+ * same divider affordance as `/compact` instead of the generic `[handoff]` box.
+ */
+export declare class HandoffSummaryMessageComponent extends SummaryMessageComponent {
+    constructor(message: CustomMessage<unknown>);
+}
+export declare function createHandoffSummaryMessageComponent(message: CustomMessage<unknown>, expanded: boolean): HandoffSummaryMessageComponent | undefined;
+/**
+ * A branch summary collapses a side branch back into the main line. Render it
+ * with the same slim divider as `/compact` and handoff rather than a `[branch]`
+ * box, so every history-collapse point reads as one consistent banner.
+ */
+export declare class BranchSummaryMessageComponent extends SummaryMessageComponent {
+    constructor(message: BranchSummaryMessage);
+}
+export {};

package/dist/types/chat/custom-message.d.ts

@@ -0,0 +1,10 @@
+import { FramedMessageComponent } from "../chrome/message-frame.js";
+import type { MessageRenderer } from "./extension-types.js";
+import { type CustomMessage } from "./messages.js";
+/**
+ * Component that renders a custom message entry from extensions.
+ * Uses distinct styling to differentiate from user messages.
+ */
+export declare class CustomMessageComponent extends FramedMessageComponent<CustomMessage<unknown>> {
+    constructor(message: CustomMessage<unknown>, customRenderer?: MessageRenderer);
+}

package/dist/types/chat/display-preferences.d.ts

@@ -0,0 +1,13 @@
+/** Process-wide display preferences applied by the host settings hooks. */
+export interface ChatTranscriptDisplayPreferences {
+    hideToolActivity: boolean;
+    readToolResultPreview: boolean;
+    showImages: boolean;
+    cacheMissMarker: boolean;
+    showTokenUsage: boolean;
+    showTurnTime: boolean;
+}
+/** Current transcript display preferences. */
+export declare const chatTranscriptDisplayPreferences: ChatTranscriptDisplayPreferences;
+/** Apply host display preferences without pulling settings into the renderer. */
+export declare function setChatTranscriptDisplayPreferences(preferences: Partial<ChatTranscriptDisplayPreferences>): void;

package/dist/types/chat/eval-execution.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Component for displaying user-initiated eval execution with streaming output.
+ * Shares the same kernel session as the agent's eval tool.
+ */
+import { Container, type TUI } from "../tui.js";
+import type { OutputArtifactError } from "../tools/streaming-output.js";
+import type { TruncationMeta } from "../tools/output-meta.js";
+export type EvalExecutionLanguage = "python" | "js";
+export declare class EvalExecutionComponent extends Container {
+    #private;
+    constructor(code: string, ui: TUI, excludeFromContext?: boolean, language?: EvalExecutionLanguage);
+    /**
+     * Transcript finalization contract (see `FinalizableBlock`): the collapsed
+     * streaming preview rewrites its tail window every chunk, so the block must
+     * stay out of native scrollback until the cell completes.
+     */
+    isTranscriptBlockFinalized(): boolean;
+    getTranscriptBlockVersion(): number;
+    setExpanded(expanded: boolean): void;
+    invalidate(): void;
+    appendOutput(chunk: string): void;
+    setComplete(exitCode: number | undefined, cancelled: boolean, options?: {
+        output?: string;
+        truncation?: TruncationMeta;
+        artifactError?: OutputArtifactError;
+    }): void;
+    getOutput(): string;
+    getCode(): string;
+}

package/dist/types/chat/execution-shared.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Shared rendering primitives for bash/eval execution components.
+ *
+ * Each helper isolates a piece of structure both components share verbatim
+ * (frame layout and post-run status line). Differences in
+ * how each component prepares its header, output lines, or sixel masking
+ * stay in their respective files.
+ */
+import { Loader } from "../components/loader.js";
+import { Text } from "../components/text.js";
+import { Container, type TUI } from "../tui.js";
+import type { OutputArtifactError } from "../tools/streaming-output.js";
+import { type TruncationMeta } from "../tools/output-meta.js";
+/** Output rows shown while an execution is collapsed. */
+export declare const PREVIEW_LINES = 20;
+/** Maximum visible columns retained from an execution output line. */
+export declare const MAX_DISPLAY_LINE_CHARS = 4000;
+/** Clamp execution output by visible width without splitting ANSI sequences. */
+export declare function clampDisplayLine(line: string): string;
+export type ExecutionStatus = "running" | "complete" | "cancelled" | "error";
+/** Theme color keys valid for an execution frame. */
+export type ExecutionColorKey = "dim" | "bashMode" | "pythonMode";
+/**
+ * Build the spacer + top border + content container + bottom border scaffold
+ * that bash and eval execution components share. The caller appends the
+ * header (command vs `>>>` prompt) and the returned loader to
+ * `contentContainer` so per-mode order is preserved.
+ */
+export declare function buildExecutionFrame(parent: Container, ui: TUI, colorKey: ExecutionColorKey): {
+    contentContainer: Container;
+    loader: Loader;
+};
+/**
+ * Build the post-run status block (hidden-line hint, exit/cancel marker,
+ * truncation notice). Returns undefined when there is nothing to display so
+ * callers can skip appending a stray Text child.
+ */
+export declare function buildStatusFooter(opts: {
+    status: ExecutionStatus;
+    exitCode: number | undefined;
+    truncation: TruncationMeta | undefined;
+    artifactError?: OutputArtifactError;
+    hiddenLineCount: number;
+    /** Suppress the "… N more lines" hint (used when sixel passthrough renders the full output). */
+    suppressHiddenCount?: boolean;
+}): Text | undefined;
+/**
+ * Derive the post-run status from an exit code + cancellation flag using the
+ * same precedence both execution components apply.
+ */
+export declare function resolveExecutionStatus(exitCode: number | undefined, cancelled: boolean): ExecutionStatus;

package/dist/types/chat/extension-types.d.ts

@@ -0,0 +1,28 @@
+import type { Component, TUI } from "../tui.js";
+import type { Theme } from "../theme/theme.js";
+import type { CustomMessage, HookMessage } from "./messages.js";
+export type ExtensionUiComponent = Component & {
+    dispose?(): void;
+};
+export type ExtensionUiComponentFactory = (tui: TUI, theme: Theme) => ExtensionUiComponent;
+export type ExtensionWidgetContent = string[] | ExtensionUiComponentFactory | undefined;
+export interface MessageRenderOptions {
+    expanded: boolean;
+}
+export type MessageRenderer<T = unknown> = (message: CustomMessage<T>, options: MessageRenderOptions, theme: Theme) => Component | undefined;
+export interface AssistantThinkingRenderContext {
+    contentIndex: number;
+    thinkingIndex: number;
+    text: string;
+    requestRender(): void;
+}
+export type AssistantThinkingRenderer = (context: AssistantThinkingRenderContext, theme: Theme) => Component | undefined;
+export interface HookMessageRenderOptions {
+    /** Whether the view is expanded */
+    expanded: boolean;
+}
+/**
+ * Renderer for hook messages.
+ * Hooks register these to provide custom TUI rendering for their message types.
+ */
+export type HookMessageRenderer<T = unknown> = (message: HookMessage<T>, options: HookMessageRenderOptions, theme: Theme) => Component | undefined;

package/dist/types/chat/hook-message.d.ts

@@ -0,0 +1,10 @@
+import { FramedMessageComponent } from "../chrome/message-frame.js";
+import type { HookMessageRenderer } from "./extension-types.js";
+import type { HookMessage } from "./messages.js";
+/**
+ * Component that renders a custom message entry from hooks.
+ * Uses distinct styling to differentiate from user messages.
+ */
+export declare class HookMessageComponent extends FramedMessageComponent<HookMessage<unknown>> {
+    constructor(message: HookMessage<unknown>, customRenderer?: HookMessageRenderer);
+}

package/dist/types/chat/image-loading.d.ts

@@ -0,0 +1,46 @@
+import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
+export declare const MAX_IMAGE_INPUT_BYTES: number;
+export declare const SUPPORTED_INPUT_IMAGE_MIME_TYPES: Set<string>;
+/**
+ * Ollama and its local-backend family decode image input through llama.cpp /
+ * `stb_image`, which is compiled without WebP support, so a WebP upload fails
+ * with an opaque HTTP 400. Detect those models so the resize pipeline encodes
+ * to PNG/JPEG instead — the automatic equivalent of `OMP_NO_WEBP=1`.
+ */
+export declare function modelLacksWebpSupport(model: Pick<Model, "provider" | "api" | "imageInputDecoder"> | undefined): boolean;
+/**
+ * `true` when `model` cannot decode WebP, otherwise `undefined` so the
+ * `OMP_NO_WEBP` env fallback in {@link resizeImage} still applies. Feed straight
+ * into {@link ImageResizeOptions.excludeWebP}.
+ */
+export declare function webpExclusionForModel(model: Pick<Model, "provider" | "api"> | undefined): true | undefined;
+export declare class ImageInputTooLargeError extends Error {
+    readonly bytes: number;
+    readonly maxBytes: number;
+    constructor(bytes: number, maxBytes: number);
+}
+/**
+ * Raised when image bytes cannot be decoded — a truncated stream, a payload
+ * with a hole in the middle, or bytes that are not the container they claim.
+ * Failing at ingress keeps them out of the transcript, where they would
+ * otherwise be persisted and rejected by the provider on every later request,
+ * with no way to resume the session.
+ */
+export declare class InvalidImageDataError extends Error {
+    readonly reason: string;
+    constructor(label: string, mimeType: string, reason: string);
+}
+/**
+ * Why an image cannot be decoded, or `null` when it decodes.
+ *
+ * A full decode is the only check that matches what vision backends accept: a
+ * middle-elided PNG keeps its signature, its header, and even a well-formed
+ * `IEND` trailer, so header sniffing and chunk-framing walks both pass it —
+ * while real-world images that decoders render happily do have odd framing, so
+ * a structural walk rejects payloads providers accept. Decoding is the ground
+ * truth on both sides. Callers on hot paths must cache the verdict.
+ */
+export declare function imageDecodeFailureReason(image: ImageContent): Promise<string | null>;
+/** Converts an image to PNG, rejecting when the runtime cannot decode or encode it. */
+export declare function convertImageToPng(image: ImageContent): Promise<ImageContent>;
+export declare function ensureSupportedImageInput(image: ImageContent): Promise<ImageContent | null>;

package/dist/types/chat/late-diagnostics-message.d.ts

@@ -0,0 +1,21 @@
+import { Container } from "../tui.js";
+/** One file's worth of late LSP diagnostics, as carried on the transcript message. */
+export interface LateDiagnosticsFile {
+    path?: string;
+    summary?: string;
+    errored?: boolean;
+    messages?: string[];
+}
+/**
+ * Renders late LSP diagnostics (arrived after edit/write returned) in the
+ * transcript, reusing the same tree renderer the edit/write tools use so the
+ * styling stays consistent. Supports the global tool-output expand toggle.
+ */
+export declare class LateDiagnosticsMessageComponent extends Container {
+    #private;
+    constructor(files: LateDiagnosticsFile[]);
+    setExpanded(expanded: boolean): void;
+    setToolActivityVisible(visible: boolean): void;
+    render(width: number): readonly string[];
+    invalidate(): void;
+}