indusagi 0.12.33 → 0.13.0

package/dist/types/facade/mcp-core/client.d.ts

@@ -4,7 +4,18 @@
  * Manages connection to one MCP server and provides
  * methods to list/call tools, read resources, etc.
  *
- * Reference: MCP client implementation patterns.
+ * Transport is provided by the official `@modelcontextprotocol/sdk`:
+ *   - stdio  → subprocess JSON-RPC over stdin/stdout
+ *   - http   → Streamable HTTP (POST for client→server, plus a server→client
+ *              push channel — the SDK opens the SSE stream and a standalone GET
+ *              SSE for server-initiated messages, and handles reconnect/
+ *              session-expiry by re-using the session id)
+ *   - sse    → legacy HTTP+SSE transport (when `transport: "sse"` is requested)
+ *
+ * The SDK gives us a real persistent connection, a server→client push channel,
+ * dispatch of server NOTIFICATIONS, answering of server REQUESTS (elicitation,
+ * roots/list, sampling, ping), and bounded reconnect on a dropped stream /
+ * expired session — none of which the hand-rolled POST-only transport did.
  */
 import type { MCPServerConfig, MCPToolDefinition, MCPResource, MCPPrompt, MCPToolCallResult, MCPLogHandler, MCPProgressHandler, MCPElicitationHandler, MCPRoot } from "./types.js";
 /**
@@ -29,7 +40,7 @@ export interface MCPClientOptions {
 /**
  * MCP Client - manages connection to a single MCP server.
  *
- * Supports stdio transport (subprocess communication).
+ * Supports stdio (subprocess) and HTTP (Streamable HTTP / legacy SSE) transports.
  * Provides methods to list tools, call tools, read resources, etc.
  *
  * @example
@@ -50,10 +61,8 @@ export interface MCPClientOptions {
  */
 export declare class MCPClient {
     private options;
-    private process?;
-    private buffer;
-    private messageId;
-    private pendingRequests;
+    private client?;
+    private transport?;
     private isConnected;
     private connectionPromise;
     private serverCapabilities?;
@@ -61,6 +70,13 @@ export declare class MCPClient {
     private enableServerLogs;
     private enableProgressTracking;
     private _roots;
+    private elicitationHandler?;
+    private samplingHandler?;
+    private resourceUpdatedHandler?;
+    private resourceListChangedHandler?;
+    private toolListChangedHandler?;
+    private promptListChangedHandler?;
+    private progressHandler?;
     /** Server name */
     readonly serverName: string;
     /** Server config */
@@ -74,10 +90,37 @@ export declare class MCPClient {
      */
     connect(): Promise<void>;
     private doConnect;
-    private connectHttp;
-    private connectStdio;
+    /**
+     * Build the SDK transport for the configured server.
+     *
+     *  - stdio: `StdioClientTransport` (inherits the parent env, merges config.env).
+     *  - http:  `StreamableHTTPClientTransport` (POST + server-push SSE channel,
+     *           reconnect + session-expiry handled by the SDK), unless the config
+     *           asks for the legacy `SSEClientTransport`.
+     */
+    private createTransport;
+    /**
+     * Register handlers for server-initiated REQUESTS and NOTIFICATIONS.
+     *
+     * REQUESTS (have both `.method` AND `.id`) must be ANSWERED with a JSON-RPC
+     * RESPONSE carrying the matching id — the SDK does this automatically for the
+     * value a request handler returns (or rejects). The previous hand-rolled
+     * transport routed these into the notification path, so they were never
+     * answered (bug #13).
+     *
+     * Defaults:
+     *   - ping              → {}
+     *   - roots/list        → the configured roots
+     *   - elicitation/create→ decline ({action:"cancel"}) unless a host handler is set
+     *   - sampling          → reject "Method not found" unless a host handler is set
+     */
+    private registerServerHandlers;
     /**
      * Disconnect from the MCP server.
+     *
+     * The SDK's `client.close()` closes the transport and rejects any pending
+     * requests — a clean teardown for both stdio (graceful subprocess shutdown)
+     * and HTTP (close the push channel / end the session).
      */
     disconnect(): Promise<void>;
     /**
@@ -134,24 +177,37 @@ export declare class MCPClient {
      * Set a handler for resource list changed notifications.
      */
     setResourceListChangedHandler(handler: () => void): void;
+    /**
+     * Set a handler for tool list changed notifications.
+     */
+    setToolListChangedHandler(handler: () => void): void;
     /**
      * Set a handler for prompt list changed notifications.
      */
     setPromptListChangedHandler(handler: () => void): void;
     /**
-     * Set a handler for elicitation requests.
+     * Set a handler for elicitation requests. When set, the server's
+     * `elicitation/create` REQUEST is answered with the host's decision; when
+     * unset the request is declined ({action:"cancel"}).
      */
     setElicitationHandler(handler: MCPElicitationHandler): void;
+    /**
+     * Set a handler for sampling (`sampling/createMessage`) requests. When set,
+     * the server request is answered with the host's result; when unset the
+     * request is rejected with "Method not found".
+     */
+    setSamplingHandler(handler: (params: unknown) => Promise<unknown>): void;
     /**
      * Set a handler for progress notifications.
      */
     setProgressHandler(handler: MCPProgressHandler): void;
     private ensureConnected;
-    private sendRequest;
-    private sendHttpRequest;
-    private sendNotification;
-    private processBuffer;
-    private handleMessage;
-    private handleNotification;
+    /**
+     * Normalize an SDK/transport error into an MCPError. Session-expiry style
+     * failures (404 session / -32001) are surfaced as SESSION_ERROR so callers
+     * (the pool) can decide to reconnect; the SDK's StreamableHTTP transport
+     * already attempts a bounded reconnect re-using the session id before this.
+     */
+    private wrapError;
     private log;
 }

package/dist/types/facade/mcp-core/client.test.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MCP client transport tests (#23 / bug #13).
+ *
+ * These verify the server→client directions that the old hand-rolled,
+ * POST-only transport never handled:
+ *   1. A server-initiated REQUEST (`elicitation/create`) is ANSWERED with a
+ *      JSON-RPC RESPONSE carrying the matching id (not silently dropped into a
+ *      notification path).
+ *   2. A server-initiated NOTIFICATION (`notifications/tools/list_changed`)
+ *      fires the host-registered handler.
+ *   3. The HTTP path builds a real Streamable-HTTP transport with a server-push
+ *      channel, and an SSE-framed server message off that channel is parsed and
+ *      dispatched to the right handler.
+ *
+ * A `MockTransport` (implementing the SDK `Transport` interface) drives the
+ * client without a live MCP server.
+ */
+export {};

package/dist/types/facade/mcp-core/types.d.ts

@@ -27,6 +27,12 @@ export interface HttpServerConfig {
     url: URL;
     /** Optional headers for HTTP requests */
     headers?: Record<string, string>;
+    /**
+     * Which HTTP transport to use.
+     *  - "http" (default): Streamable HTTP (single endpoint, server-push channel)
+     *  - "sse": legacy HTTP+SSE transport
+     */
+    transport?: "http" | "sse";
     /** Custom fetch implementation */
     fetch?: typeof fetch;
 }
@@ -166,6 +172,8 @@ export interface MCPServerConfigEntry {
     url?: string;
     /** Headers for HTTP transport */
     headers?: Record<string, string>;
+    /** HTTP transport flavor ("http" = Streamable HTTP default, "sse" = legacy) */
+    transport?: "http" | "sse";
     /** Timeout in milliseconds */
     timeout?: number;
     /** Whether this server is enabled (default: true) */
@@ -185,6 +193,8 @@ export interface MCPServerConfigValue {
     url?: string;
     /** Headers for HTTP transport */
     headers?: Record<string, string>;
+    /** HTTP transport flavor ("http" = Streamable HTTP default, "sse" = legacy) */
+    transport?: "http" | "sse";
     /** Timeout in milliseconds */
     timeout?: number;
     /** Whether this server is enabled (default: true) */

package/dist/types/facade/ml/adapters/anthropic-retry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/facade/ml/adapters/anthropic.d.ts

@@ -57,5 +57,22 @@ export declare class AnthropicStreamHandler extends BaseStreamHandler {
      */
     process(anthropicStream: AsyncIterable<unknown>, onEvent: (event: any) => void): Promise<void>;
 }
+/**
+ * Reads a `Retry-After` header off an Anthropic APIError and converts it to a
+ * delay in milliseconds. The header is the integer-seconds form per the
+ * Anthropic API; a missing/non-numeric value yields `null` so callers fall
+ * back to exponential backoff.
+ */
+export declare function parseAnthropicRetryAfterMs(error: unknown): number | null;
+/**
+ * Classifies an Anthropic failure as worth retrying. Mirrors
+ * `kit/provider-errors.ts:isRetryableError`: transient HTTP statuses (408/409/
+ * 429/529/5xx) and an `overloaded_error` body are retryable; auth/validation
+ * (401/403/4xx) are not. Generic errors fall back to a message sniff covering
+ * network/timeout/overload conditions. The `_attempt` is accepted to satisfy
+ * the RetryPolicy.shouldRetry contract but unused here (the loop already caps
+ * attempts).
+ */
+export declare function shouldRetryAnthropic(error: unknown, _attempt: number): boolean;
 export declare const streamAnthropic: StreamFunction<"anthropic-messages", AnthropicOptions>;
 export declare const streamSimpleAnthropic: StreamFunction<"anthropic-messages", SimpleStreamOptions>;

package/dist/types/facade/ml/adapters/simple-options.d.ts

@@ -8,7 +8,20 @@ export interface RetryPolicy {
     maxAttempts: number;
     baseDelayMs: number;
     maxDelayMs?: number;
+    /**
+     * When present, abort is checked between attempts and before each backoff
+     * sleep. A live request is short-circuited the moment its signal fires —
+     * but the presence of a signal no longer suppresses transient retries.
+     */
+    signal?: AbortSignal;
     shouldRetry?: (error: unknown, attempt: number) => boolean;
+    /**
+     * Returns the server-requested cooldown (e.g. a parsed `Retry-After`
+     * header) in milliseconds, or `null` when the error carries no such hint.
+     * When provided, it takes priority over exponential backoff (still clamped
+     * by `maxDelayMs`).
+     */
+    getRetryAfterMs?: (error: unknown) => number | null;
 }
 export declare class SimpleOptionsProviderError extends Error {
     readonly code: "rate_limit" | "timeout" | "network" | "validation" | "auth" | "unknown";

package/dist/types/facade/ml/adapters/simple-options.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/react-ink/components/StatusLine.d.ts

@@ -4,6 +4,15 @@ interface StatusLineProps {
     theme: InkThemeAdapter;
     status?: StatusMessage;
     snapshot: SessionSnapshot;
+    /**
+     * Whether this line draws its own "Agent working..." / "Running bash..." /
+     * "Compacting..." busy fallbacks. Defaults to `true` (legacy behaviour). A host
+     * that renders its own live progress affordance (e.g. an animated working
+     * indicator on a separate row) passes `false` so the busy state is shown in ONE
+     * place only — this line then carries just the explicit transient toast (and a
+     * hard error), and never competes with the host's indicator.
+     */
+    showBusyText?: boolean;
 }
-export declare function StatusLine({ snapshot, status, theme }: StatusLineProps): JSX.Element | null;
+export declare function StatusLine({ snapshot, status, theme, showBusyText }: StatusLineProps): JSX.Element | null;
 export {};

package/dist/types/react-ink/components/ToolEventBlock.d.ts

@@ -12,6 +12,14 @@ interface ToolEventBlockProps {
     showTitle?: boolean;
     showSummaryInline?: boolean;
     maxContentLines?: number;
+    /**
+     * When true the detail body already carries syntax-highlight ANSI; render it
+     * verbatim instead of stripping the escapes. stripAnsi is still used for the
+     * visible-width / line-count measurements so wrapping and clamping stay
+     * correct against the escape-free text.
+     */
+    preformatted?: boolean;
 }
-export declare function ToolEventBlock({ detail, emptyText, indent, marginBottom, maxContentLines, showSummaryInline, showTitle, status, summary, theme: _theme, title, }: ToolEventBlockProps): JSX.Element;
+export declare function statusColorKey(status: ToolEventStatus): string;
+export declare function ToolEventBlock({ detail, emptyText, indent, marginBottom, maxContentLines, preformatted, showSummaryInline, showTitle, status, summary, theme, title, }: ToolEventBlockProps): JSX.Element;
 export {};

package/dist/types/react-ink/components/ToolEventBlock.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/react-ink/components/dialogs/SelectableDialog.d.ts

@@ -9,8 +9,14 @@ interface SelectableDialogProps<T> {
     noSearchResultsText?: string;
     onClose: () => void;
     onSelect: (item: T) => void | Promise<void>;
+    /**
+     * Fired whenever the highlighted item changes (including on first mount), so a
+     * caller can live-preview the currently-focused choice before it is committed
+     * with Enter. Distinct from {@link onSelect}, which fires only on Enter.
+     */
+    onHighlight?: (item: T, index: number) => void;
     getSearchText?: (item: T) => string;
     renderItem: (item: T, selected: boolean, index: number) => ReactNode;
 }
-export declare function SelectableDialog<T>({ title, subtitle, items, isActive, searchEnabled, emptyText, noSearchResultsText, onClose, onSelect, getSearchText, renderItem, }: SelectableDialogProps<T>): JSX.Element;
+export declare function SelectableDialog<T>({ title, subtitle, items, isActive, searchEnabled, emptyText, noSearchResultsText, onClose, onSelect, onHighlight, getSearchText, renderItem, }: SelectableDialogProps<T>): JSX.Element;
 export {};

package/dist/types/react-ink/components/dialogs/ThemeDialog.d.ts

@@ -1,7 +1,26 @@
+/**
+ * A single selectable scheme row. The `id` is the scheme token committed/
+ * previewed; `label` and `description` are the human-readable strings shown.
+ */
+export interface ThemeDialogItem {
+    id: string;
+    label: string;
+    description?: string;
+}
 interface ThemeDialogProps {
-    themes: string[];
+    /**
+     * The schemes to offer. Either bare scheme tokens (label == token) or rich
+     * items carrying a friendly label + description.
+     */
+    themes: Array<string | ThemeDialogItem>;
     onClose: () => void;
+    /** Fired on Enter: the chosen scheme token. */
     onSelect: (themeName: string) => void | Promise<void>;
+    /**
+     * Fired on every highlight move (and on mount): the focused scheme token, so
+     * the caller can live-preview a scheme before it is committed.
+     */
+    onHighlight?: (themeName: string) => void;
 }
-export declare function ThemeDialog({ themes, onClose, onSelect }: ThemeDialogProps): JSX.Element;
+export declare function ThemeDialog({ themes, onClose, onSelect, onHighlight }: ThemeDialogProps): JSX.Element;
 export {};

package/dist/types/react-ink/diff/Diff.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "indusagi/react-host";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+import type { StructuredDiff } from "./structured.js";
+interface DiffProps {
+    diff: StructuredDiff;
+    theme: InkThemeAdapter;
+    /** Left margin (columns) applied to the whole block. */
+    indent?: number;
+    marginBottom?: number;
+}
+/**
+ * A minimal, pure-Ink colored diff block.
+ *
+ * Renders each hunk's classified lines with a right-aligned line-number gutter,
+ * themed add/remove backgrounds, and word-level intra-line emphasis (only the
+ * changed sub-ranges are bolded; suppressed above the change threshold upstream
+ * in {@link buildStructuredDiff}). Multiple hunks are separated by a dim `...`
+ * marker. No state, no effects — colors survive to the terminal because nothing
+ * strips the ANSI on this path.
+ */
+export declare function Diff({ diff, theme, indent, marginBottom }: DiffProps): ReactNode;
+export {};

package/dist/types/react-ink/diff/diff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/react-ink/diff/structured.d.ts

@@ -0,0 +1,41 @@
+import { type WordSpan } from "./word-diff.js";
+/** Lines of unchanged context kept around each change, matching git's default. */
+export declare const CONTEXT_LINES = 3;
+/** A single rendered diff line, already classified and numbered. */
+export interface DiffLine {
+    kind: "context" | "added" | "removed";
+    /** The old-file line number, or undefined for added lines. */
+    oldLine?: number;
+    /** The new-file line number, or undefined for removed lines. */
+    newLine?: number;
+    /** The line text without its `+`/`-`/space diff prefix. */
+    text: string;
+    /**
+     * Word-level segments for intra-line highlighting. Present only on added /
+     * removed lines that were paired with their counterpart; context lines and
+     * unpaired changes leave this undefined (render the whole line one colour).
+     */
+    spans?: WordSpan[];
+}
+/** One contiguous change region: classified lines plus a hunk header marker. */
+export interface DiffHunk {
+    oldStart: number;
+    newStart: number;
+    lines: DiffLine[];
+}
+export interface StructuredDiff {
+    hunks: DiffHunk[];
+    addedCount: number;
+    removedCount: number;
+}
+/**
+ * Build a structured diff between `oldStr` and `newStr` using the `diff`
+ * package's {@link structuredPatch} with {@link CONTEXT_LINES} of context.
+ *
+ * The raw hunk `lines` (prefixed `+`/`-`/space) are walked into typed
+ * {@link DiffLine}s carrying gutter line numbers. Adjacent removed→added runs
+ * are paired index-for-index and handed to {@link wordDiffLine} so the renderer
+ * can emphasise only the changed sub-range of each line. Returns `null` when
+ * there is nothing to show (identical input or an empty patch).
+ */
+export declare function buildStructuredDiff(oldStr: string, newStr: string, filePath?: string): StructuredDiff | null;

package/dist/types/react-ink/diff/word-diff.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Above this fraction of a line changing, intra-line word highlighting reads as
+ * noise — almost every span is "changed", so a flat whole-line colour is
+ * clearer. Below it we paint only the genuinely altered sub-ranges brighter.
+ */
+export declare const CHANGE_THRESHOLD = 0.4;
+/** One contiguous run of a removed/added line, flagged whether it changed. */
+export interface WordSpan {
+    text: string;
+    /** True when this run differs between the old and new line. */
+    changed: boolean;
+}
+/**
+ * Pair a removed line with the added line that replaced it and return the
+ * per-segment word diff for ONE side.
+ *
+ * `side` selects which line's segments we want: a removed-line render wants the
+ * segments present in the old text (unchanged + removed), an added-line render
+ * wants the segments present in the new text (unchanged + added). The other
+ * side's segments are dropped so the caller paints exactly the line it is on.
+ *
+ * Word highlighting is suppressed — the whole line is returned as a single
+ * `changed: true` span — when the changed character fraction exceeds
+ * {@link CHANGE_THRESHOLD}, where scattered word spans read worse than a flat
+ * line colour. The returned spans always concatenate back to the original line.
+ */
+export declare function wordDiffLine(oldLine: string, newLine: string, side: "removed" | "added"): WordSpan[];

package/dist/types/react-ink/index.d.ts

@@ -29,6 +29,14 @@ export * from "./components/messages/SkillInvocationMessage.js";
 export * from "./components/messages/ToolCallMessage.js";
 export * from "./components/messages/ToolResultBlock.js";
 export * from "./components/messages/UserMessage.js";
+export * from "./diff/Diff.js";
+export * from "./diff/structured.js";
+export * from "./diff/word-diff.js";
+export * from "./markdown/Markdown.js";
+export * from "./markdown/MarkdownTable.js";
+export * from "./markdown/StreamingMarkdown.js";
+export * from "./markdown/format-token.js";
+export * from "./markdown/highlight.js";
 export * from "./utils/message-groups.js";
 export * from "./utils/selection-dialog.js";
 export * from "./utils/tool-display.js";

package/dist/types/react-ink/markdown/Markdown.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "indusagi/react-host";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface MarkdownProps {
+    /** The raw markdown source to render. */
+    children: string;
+    /** The theme adapter colours resolve against. */
+    theme: InkThemeAdapter;
+    /** When false, fenced code is rendered plain (no syntax highlighting). */
+    highlightCode?: boolean;
+    /** Render every text run dim (used for de-emphasised content). */
+    dim?: boolean;
+}
+/**
+ * Render markdown as styled terminal output.
+ *
+ * Tables become real flexbox columns ({@link MarkdownTable}); every other token
+ * is formatted to a chalk-ANSI string via {@link formatToken} and accumulated
+ * into a single `<Text>` run. Ink passes embedded ANSI straight to the terminal,
+ * so the chalk escapes render as colour. The `theme` is passed explicitly — the
+ * rebuild has no `useTheme()` hook.
+ */
+export declare function Markdown({ children, theme, highlightCode, dim }: MarkdownProps): ReactNode;
+export {};

package/dist/types/react-ink/markdown/MarkdownTable.d.ts

@@ -0,0 +1,19 @@
+import type { Tokens } from "marked";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+import type { CliHighlight } from "./highlight.js";
+interface MarkdownTableProps {
+    token: Tokens.Table;
+    theme: InkThemeAdapter;
+    highlight?: CliHighlight | null;
+}
+/**
+ * Render a GFM table token as aligned flexbox columns.
+ *
+ * Each column's width is measured from the stripAnsi'd display text (so embedded
+ * ANSI styling does not inflate the column), the header row is bold, a dash rule
+ * separates header from body, and every cell is padded per its column alignment.
+ * Cells render as `<Box>` columns inside `<Box flexDirection="row">` rows, so Ink
+ * lays them out as real columns rather than a raw `| a | b |` pipe string.
+ */
+export declare function MarkdownTable({ token, theme, highlight }: MarkdownTableProps): JSX.Element;
+export {};

package/dist/types/react-ink/markdown/StreamingMarkdown.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from "indusagi/react-host";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+interface StreamingMarkdownProps {
+    /** The accumulated answer text so far (grows monotonically per delta). */
+    children: string;
+    /** The theme adapter colours resolve against. */
+    theme: InkThemeAdapter;
+    /** When false, fenced code is rendered plain (no syntax highlighting). */
+    highlightCode?: boolean;
+    /** Render every text run dim. */
+    dim?: boolean;
+}
+/**
+ * Streaming-aware markdown renderer with a monotonic stable-prefix boundary.
+ *
+ * On every delta the accumulated answer grows. Re-lexing the whole answer each
+ * time would re-parse (and reflow/flicker) content that is already settled. To
+ * avoid that, we split the answer at the last completed block boundary:
+ *
+ *   - **stable prefix** — every block above the boundary. Memoised on its own
+ *     content, so once a block settles its `<Markdown>` is parsed once and never
+ *     re-renders as later deltas arrive.
+ *   - **unstable suffix** — the still-growing last block. Re-lexed every delta
+ *     (cheap: it is one block, and `Markdown`'s own LRU cache + fast-path absorb
+ *     the cost).
+ *
+ * The boundary only ever moves forward (it is recomputed from `content`, which
+ * grows monotonically, and `lastStableBoundary` is monotonic in its input), so
+ * completed blocks never re-flicker. When the turn ends and the finalized
+ * assistant message takes over rendering, the same `<Markdown>` pipeline draws
+ * identical output, so the hand-off is seamless.
+ */
+export declare function StreamingMarkdown({ children, theme, highlightCode, dim, }: StreamingMarkdownProps): ReactNode;
+export {};

package/dist/types/react-ink/markdown/format-token.d.ts

@@ -0,0 +1,39 @@
+import { type Token } from "marked";
+import type { InkThemeAdapter } from "../theme-adapter.js";
+import type { CliHighlight } from "./highlight.js";
+/**
+ * Configure the shared `marked` instance exactly once. The only customisation is
+ * disabling strikethrough: models frequently write `~` for "approximate"
+ * (e.g. `~100`) and almost never intend an actual strike, so we keep `~` literal.
+ */
+export declare function configureMarked(): void;
+/**
+ * Fast structural check for whether `text` contains any markdown syntax. Samples
+ * the first 500 chars — markdown markers (headings, fences, list bullets) cluster
+ * at the start, while long plain tails (tool output) stay markdown-free.
+ */
+export declare function hasMarkdownSyntax(text: string): boolean;
+/**
+ * Lex `content` into marked tokens, hitting the LRU cache and the plain-text
+ * fast-path. Plain text (no markdown syntax) returns a single synthetic
+ * paragraph token and is intentionally not cached — reconstruction is one
+ * allocation and caching would retain the content for no benefit.
+ */
+export declare function cachedLexer(content: string): Token[];
+/**
+ * Render a single marked token to a chalk-ANSI string, painting via the
+ * framework {@link InkThemeAdapter}. Tables are handled out-of-band by the
+ * `Markdown` component (rendered as flexbox), so this returns an empty string
+ * for `table` tokens — the caller never funnels a table through here.
+ */
+export declare function formatToken(token: Token, theme: InkThemeAdapter, highlight?: CliHighlight | null, listDepth?: number, orderedListNumber?: number | null, parent?: Token | null): string;
+/** Pick the list-marker style for a depth: 1./2. → a./b. → i./ii. → numeric. */
+export declare function getListNumber(listDepth: number, orderedListNumber: number): string;
+/**
+ * Pad `content` to `targetWidth` per alignment. `displayWidth` is the visible
+ * width of `content` (caller computes it on stripAnsi'd text so embedded ANSI
+ * codes do not skew the padding).
+ */
+export declare function padAligned(content: string, displayWidth: number, targetWidth: number, align: "left" | "center" | "right" | null | undefined): string;
+/** Measure a string's visible terminal width (ANSI-aware), for table layout. */
+export declare function stringWidth(text: string): number;

package/dist/types/react-ink/markdown/highlight.d.ts

@@ -0,0 +1,31 @@
+import type { InkThemeAdapter } from "../theme-adapter.js";
+/**
+ * The shape {@link formatToken} (and the tool-body highlighter) consume. It is a
+ * deliberately small surface: ask whether a language is known, then hand back a
+ * chalk-ANSI rendering of the code. Keeping it behind an interface means the
+ * markdown formatter never imports highlight.js directly and a caller can pass
+ * `null` to disable highlighting entirely.
+ */
+export interface CliHighlight {
+    /** Whether highlight.js has a grammar registered for `language`. */
+    supportsLanguage: (language: string) => boolean;
+    /** Render `code` as a chalk-ANSI string, colouring scopes via the theme. */
+    highlight: (code: string, options: {
+        language: string;
+    }) => string;
+}
+/**
+ * Build a {@link CliHighlight} bound to a theme. The returned object paints each
+ * highlight.js scope via the theme's syntax roles ({@link ThemeRole}); unknown
+ * languages and any internal failure fall back to the raw code, never throwing.
+ */
+export declare function createHighlighter(theme: InkThemeAdapter): CliHighlight;
+/**
+ * Highlight `code` keyed on a file path's extension. Used by the read/write/edit
+ * tool bodies, which know the file but not a fenced ```lang tag. Resolves the
+ * extension to a highlight.js language, falling back to the plain code when the
+ * extension is unknown or unsupported.
+ */
+export declare function highlightByPath(code: string, filePath: string, theme: InkThemeAdapter): string;
+/** Resolve a file path to a highlight.js language id, or null when unknown. */
+export declare function languageFromPath(filePath: string): string | null;