jeopi-cli 16.2.14 → 16.2.17

package/dist/types/tools/sqlite-reader.d.ts

@@ -0,0 +1,114 @@
+import type { Database } from "bun:sqlite";
+export declare function looksLikeSqlite(bytes: Uint8Array): boolean;
+/** Row cap for raw `?q=` SQL — protects against `SELECT *` on multi-million-row tables. */
+export declare const MAX_RAW_QUERY_ROWS = 1000;
+export interface SqlitePathCandidate {
+    sqlitePath: string;
+    subPath: string;
+    queryString: string;
+}
+export type SqliteSelector = {
+    kind: "list";
+} | {
+    kind: "schema";
+    table: string;
+    sampleLimit: number;
+} | {
+    kind: "row";
+    table: string;
+    key: string;
+} | {
+    kind: "query";
+    table: string;
+    limit: number;
+    offset: number;
+    order?: string;
+    where?: string;
+} | {
+    kind: "raw";
+    sql: string;
+};
+export type SqliteRowLookup = {
+    kind: "pk";
+    column: string;
+    type: string;
+} | {
+    kind: "rowid";
+};
+/**
+ * Row count for a table in the listing.
+ * - `exact`: counted in full (the table is small enough to count cheaply).
+ * - `estimate`: the planner's `sqlite_stat1` figure; the table is too large to
+ *   scan, so this may be stale.
+ * - `atLeast`: a lower bound; counting was capped before reaching the end.
+ */
+export type TableRowCount = {
+    kind: "exact";
+    rows: number;
+} | {
+    kind: "estimate";
+    rows: number;
+} | {
+    kind: "atLeast";
+    rows: number;
+};
+export interface SqliteTableSummary {
+    name: string;
+    count: TableRowCount;
+}
+export declare function parseSqlitePathCandidates(filePath: string): SqlitePathCandidate[];
+export declare function isSqliteFile(absolutePath: string): Promise<boolean>;
+export declare function parseSqliteSelector(subPath: string, queryString: string): SqliteSelector;
+export declare function listTables(db: Database, options?: {
+    probeCap?: number;
+}): SqliteTableSummary[];
+export declare function getTableSchema(db: Database, table: string): string;
+export declare function getTablePrimaryKey(db: Database, table: string): {
+    column: string;
+    type: string;
+} | null;
+export declare function resolveTableRowLookup(db: Database, table: string): SqliteRowLookup;
+export declare function queryRows(db: Database, table: string, opts: {
+    limit: number;
+    offset: number;
+    order?: string;
+    where?: string;
+}): {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    totalCount: number;
+};
+export declare function getRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string): Record<string, unknown> | null;
+export declare function getRowByRowId(db: Database, table: string, key: string): Record<string, unknown> | null;
+export declare function executeReadQuery(db: Database, sql: string): {
+    columns: string[];
+    rows: Record<string, unknown>[];
+    truncated: boolean;
+};
+export declare function insertRow(db: Database, table: string, data: Record<string, unknown>): void;
+export declare function updateRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string, data: Record<string, unknown>): number;
+export declare function updateRowByRowId(db: Database, table: string, key: string, data: Record<string, unknown>): number;
+export declare function deleteRowByKey(db: Database, table: string, pk: {
+    column: string;
+    type?: string;
+}, key: string): number;
+export declare function deleteRowByRowId(db: Database, table: string, key: string): number;
+export declare function renderTableList(tables: SqliteTableSummary[]): string;
+export declare function renderSchema(createSql: string, sampleRows: {
+    columns: string[];
+    rows: Record<string, unknown>[];
+}): string;
+export declare function renderRow(row: Record<string, unknown>): string;
+export declare function renderTable(columns: string[], rows: Record<string, unknown>[], meta: {
+    totalCount: number;
+    offset: number;
+    limit: number;
+    table: string;
+    dbPath: string;
+}): string;

package/dist/types/tools/ssh.d.ts

@@ -0,0 +1,73 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { ToolExample } from "jeopi-ai";
+import type { Component } from "jeopi-tui";
+import type { SSHHost } from "../capability/ssh";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from ".";
+import { type OutputMeta } from "./output-meta";
+declare const sshSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    host: string;
+    command: string;
+    cwd?: string | undefined;
+    timeout?: number | undefined;
+}, {}>;
+export interface SSHToolDetails {
+    meta?: OutputMeta;
+}
+type SshToolParams = typeof sshSchema.infer;
+export declare class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
+    #private;
+    private readonly session;
+    private readonly hostNames;
+    private readonly hostsByName;
+    readonly description: string;
+    readonly name = "ssh";
+    readonly approval: "exec";
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    readonly summary = "Execute a command on a remote host over SSH";
+    readonly loadMode = "discoverable";
+    readonly label = "SSH";
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        host: string;
+        command: string;
+        cwd?: string | undefined;
+        timeout?: number | undefined;
+    }, {}>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    readonly examples: readonly ToolExample<SshToolParams>[];
+    constructor(session: ToolSession, hostNames: string[], hostsByName: Map<string, SSHHost>, description: string);
+    execute(_toolCallId: string, { host, command, cwd, timeout: rawTimeout }: SshToolParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<SSHToolDetails>, _ctx?: AgentToolContext): Promise<AgentToolResult<SSHToolDetails>>;
+}
+export declare function loadSshTool(session: ToolSession): Promise<SshTool | null>;
+interface SshRenderArgs {
+    host?: string;
+    command?: string;
+    timeout?: number;
+}
+interface SshRenderContext {
+    /** Visual lines for truncated output (pre-computed by tool-execution) */
+    visualLines?: string[];
+    /** Number of lines skipped */
+    skippedCount?: number;
+    /** Total visual lines */
+    totalVisualLines?: number;
+}
+export declare const sshToolRenderer: {
+    renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: SSHToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions & {
+        renderContext?: SshRenderContext;
+    }, uiTheme: Theme, args?: SshRenderArgs): Component;
+    mergeCallAndResult: boolean;
+    provisionalPendingPreview: boolean;
+    provisionalPartialResult: boolean;
+};
+export {};

package/dist/types/tools/todo.d.ts

@@ -0,0 +1,126 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { ToolExample } from "jeopi-ai";
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import type { ToolSession } from "../sdk";
+import type { SessionEntry } from "../session/session-entries";
+export type TodoStatus = "pending" | "in_progress" | "completed" | "abandoned";
+/** Operation names accepted by the todo tool and echoed in successful result details. */
+export type TodoOperation = "init" | "start" | "done" | "rm" | "drop" | "append" | "view";
+export interface TodoItem {
+    content: string;
+    status: TodoStatus;
+}
+export interface TodoPhase {
+    name: string;
+    tasks: TodoItem[];
+}
+export interface TodoCompletionTransition {
+    phase: string;
+    content: string;
+}
+export interface TodoToolDetails {
+    /** Operation that produced this snapshot; absent on legacy transcript entries. */
+    op?: TodoOperation;
+    phases: TodoPhase[];
+    storage: "session" | "memory";
+    completedTasks?: TodoCompletionTransition[];
+}
+declare const todoSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "append" | "done" | "drop" | "init" | "rm" | "start" | "view";
+    list?: {
+        phase: string;
+        items: string[];
+    }[] | undefined;
+    task?: string | undefined;
+    phase?: string | undefined;
+    items?: string[] | undefined;
+}, {}>;
+type TodoParams = TodoSchema;
+type TodoSchema = typeof todoSchema.infer;
+/** Return the active todo task, preferring an in-progress item over the first pending item. */
+export declare function nextActionableTask(phases: readonly TodoPhase[]): TodoItem | undefined;
+export declare const USER_TODO_EDIT_CUSTOM_TYPE = "user_todo_edit";
+export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]): TodoPhase[];
+/**
+ * Report whether `content` likely names the same work as any entry in
+ * `descriptions`. Used by the sticky todo panel to light up a pending todo
+ * when an in-flight subagent is doing the work for it, without requiring
+ * the caller to flip the todo's status.
+ *
+ * Matching is normalize-then-equal first (lowercased; punctuation and
+ * whitespace runs both collapsed to a single space; trimmed), with a
+ * substring fallback in either direction so minor wording drift
+ * ("Sonnet #2: bug scan" vs "Sonnet #2") still links up. The substring
+ * fallback requires at least {@link TODO_DESCRIPTION_MIN_OVERLAP} chars on
+ * the contained side.
+ */
+export declare function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean;
+/** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
+export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoParams[]): {
+    phases: TodoPhase[];
+    errors: string[];
+};
+export declare function resolveTodoMarkdownPath(input: string, cwd: string): string;
+/** Render todo phases as a Markdown checklist suitable for editing/copying. */
+export declare function phasesToMarkdown(phases: TodoPhase[]): string;
+/** Parse a Markdown checklist back into todo phases. */
+export declare function markdownToPhases(md: string): {
+    phases: TodoPhase[];
+    errors: string[];
+};
+export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
+    private readonly session;
+    readonly name = "todo";
+    readonly approval: "read";
+    readonly label = "Todo";
+    readonly summary = "Write a structured todo list to track progress within a session";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "append" | "done" | "drop" | "init" | "rm" | "start" | "view";
+        list?: {
+            phase: string;
+            items: string[];
+        }[] | undefined;
+        task?: string | undefined;
+        phase?: string | undefined;
+        items?: string[] | undefined;
+    }, {}>;
+    readonly concurrency = "exclusive";
+    readonly strict = true;
+    readonly examples: readonly ToolExample<typeof todoSchema.infer>[];
+    readonly loadMode = "discoverable";
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: TodoParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TodoToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TodoToolDetails>>;
+}
+type TodoRenderOp = {
+    op?: string;
+    task?: string;
+    phase?: string;
+    items?: string[];
+};
+/** New single-op shape `{op,...}`; legacy `{ops:[...]}` still seen in old transcripts. */
+type TodoRenderArgs = TodoRenderOp & {
+    ops?: TodoRenderOp[];
+};
+/** One-based ASCII roman numeral for display (I, II, III, IV, …). */
+export declare function phaseRomanNumeral(oneBasedIndex: number): string;
+/** Display-only phase header: `I. Foundation`. State and prompts never see this. */
+export declare function formatPhaseDisplayName(name: string, oneBasedIndex: number): string;
+export declare const TODO_STRIKE_HOLD_FRAMES = 2;
+export declare const TODO_STRIKE_REVEAL_FRAMES = 12;
+export declare const TODO_STRIKE_TOTAL_FRAMES: number;
+export declare const todoToolRenderer: {
+    renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: TodoToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: TodoRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/tool-errors.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Standardized error types for tool execution.
+ *
+ * Tools should throw these instead of returning error text.
+ * The agent loop catches and renders them appropriately.
+ */
+/**
+ * Base error for tool execution failures.
+ * Override render() for custom LLM-facing formatting.
+ */
+export declare class ToolError extends Error {
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, context?: Record<string, unknown> | undefined);
+    /** Render error for LLM consumption. Override for custom formatting. */
+    render(): string;
+}
+/**
+ * Error thrown when a tool operation is aborted (e.g., via AbortSignal).
+ */
+export declare class ToolAbortError extends Error {
+    static readonly MESSAGE = "Operation aborted";
+    constructor(message?: string);
+}
+/**
+ * Throw ToolAbortError if the signal is aborted.
+ * Use this instead of signal?.throwIfAborted() to get consistent error types.
+ */
+export declare function throwIfAborted(signal?: AbortSignal): void;
+/**
+ * Render an error for LLM consumption.
+ * Handles ToolError.render() and falls back to message/string.
+ */
+export declare function renderError(e: unknown): string;

package/dist/types/tools/tool-result.d.ts

@@ -0,0 +1,34 @@
+import type { AgentToolResult } from "jeopi-agent-core";
+import type { ImageContent, TextContent } from "jeopi-ai";
+import type { OutputSummary, TruncationResult } from "../session/streaming-output";
+import type { OutputMeta, TruncationOptions, TruncationSummaryOptions, TruncationTextOptions } from "./output-meta";
+type ToolContent = Array<TextContent | ImageContent>;
+type DetailsWithMeta = {
+    meta?: OutputMeta;
+};
+export declare class ToolResultBuilder<TDetails extends DetailsWithMeta> {
+    #private;
+    constructor(details?: TDetails);
+    text(text: string): this;
+    content(content: ToolContent): this;
+    truncation(result: TruncationResult, options: TruncationOptions): this;
+    truncationFromSummary(summary: OutputSummary, options: TruncationSummaryOptions): this;
+    truncationFromText(text: string, options: TruncationTextOptions): this;
+    limits(limits: {
+        matchLimit?: number;
+        resultLimit?: number;
+        headLimit?: number;
+        columnMax?: number;
+    }): this;
+    sourceUrl(value: string): this;
+    sourcePath(value: string): this;
+    sourceInternal(value: string): this;
+    diagnostics(summary: string, messages: string[]): this;
+    /** Flag the result as a non-throwing failure (agent-loop surfaces it as a tool error). */
+    error(value?: boolean): this;
+    /** Marks the result contextually useless — compaction may elide it once consumed. */
+    useless(value?: boolean): this;
+    done(): AgentToolResult<TDetails>;
+}
+export declare function toolResult<TDetails extends DetailsWithMeta>(details?: TDetails): ToolResultBuilder<TDetails>;
+export {};

package/dist/types/tools/tool-timeouts.d.ts

@@ -0,0 +1,51 @@
+export interface ToolTimeoutConfig {
+    /** Default timeout in seconds when agent omits the field */
+    default: number;
+    /** Minimum allowed timeout in seconds */
+    min: number;
+    /** Maximum allowed timeout in seconds (per-tool ceiling) */
+    max: number;
+}
+export declare const TOOL_TIMEOUTS: {
+    readonly bash: {
+        readonly default: 300;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly eval: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly browser: {
+        readonly default: 30;
+        readonly min: 1;
+        readonly max: 300;
+    };
+    readonly ssh: {
+        readonly default: 60;
+        readonly min: 1;
+        readonly max: 3600;
+    };
+    readonly fetch: {
+        readonly default: 20;
+        readonly min: 1;
+        readonly max: 45;
+    };
+    readonly lsp: {
+        readonly default: 20;
+        readonly min: 5;
+        readonly max: 60;
+    };
+    readonly debug: {
+        readonly default: 30;
+        readonly min: 5;
+        readonly max: 300;
+    };
+};
+export type ToolWithTimeout = keyof typeof TOOL_TIMEOUTS;
+/**
+ * Clamp a raw timeout to the allowed range for a tool.
+ * If rawTimeout is undefined, returns the tool's default.
+ */
+export declare function clampTimeout(tool: ToolWithTimeout, rawTimeout?: number): number;

package/dist/types/tools/tts.d.ts

@@ -0,0 +1,42 @@
+import type { CustomTool } from "../extensibility/custom-tools/types";
+type TtsCodec = "mp3" | "wav";
+type TtsBackend = "local" | "xai";
+declare const ttsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    text: string;
+    voice_id: import("arktype/internal/attributes.ts").Default<string, "eve">;
+    language: import("arktype/internal/attributes.ts").Default<string, "en">;
+    output_path: string;
+    sample_rate?: number | undefined;
+    bit_rate?: number | undefined;
+}, {}>;
+interface TtsToolDetails {
+    bytes: number;
+    voiceId: string;
+    codec: TtsCodec;
+    backend: TtsBackend;
+}
+/**
+ * Pick the synthesis backend. Pure for testability.
+ *
+ * - `xai` / `local` are honored verbatim (the xAI path still surfaces its own
+ *   "no credentials" error when creds are missing).
+ * - `auto` prefers the local on-device backend, except when the caller asked for
+ *   an `.mp3` and xAI credentials exist — only the cloud path can emit MP3, so we
+ *   route there to satisfy the requested container rather than substituting WAV.
+ */
+export declare function resolveTtsBackend(opts: {
+    preference: string;
+    wantsMp3: boolean;
+    hasXaiCreds: boolean;
+}): TtsBackend;
+/**
+ * Resolve the on-disk path for local synthesis. Local output is always WAV (no
+ * MP3 encoder is bundled), so an `.mp3` (or any non-`.wav`) request is rewritten
+ * to a sibling `.wav` and flagged so the tool result can note the substitution.
+ */
+export declare function resolveLocalWavPath(outputPath: string): {
+    wavPath: string;
+    substituted: boolean;
+};
+export declare const ttsTool: CustomTool<typeof ttsSchema, TtsToolDetails>;
+export {};

package/dist/types/tools/write.d.ts

@@ -0,0 +1,66 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolTier } from "jeopi-agent-core";
+import type { Component } from "jeopi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { type FileDiagnosticsResult } from "../lsp";
+import { type Theme } from "../modes/theme/theme";
+import type { ToolSession } from "../sdk";
+import { type OutputMeta } from "./output-meta";
+declare const writeSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    path: string;
+    content: string;
+}, {}>;
+export type WriteToolInput = typeof writeSchema.infer;
+/** Details returned by the write tool for TUI rendering */
+export interface WriteToolDetails {
+    diagnostics?: FileDiagnosticsResult;
+    meta?: OutputMeta;
+    /** Set when the file was auto-chmod'd because content begins with a `#!` shebang. */
+    madeExecutable?: boolean;
+    /** Absolute filesystem path the write resolved to. Used by the renderer to wrap
+     * the (possibly cwd-relative) header path in an OSC 8 `file://` hyperlink. */
+    resolvedPath?: string;
+}
+type WriteParams = WriteToolInput;
+/**
+ * Write tool implementation.
+ *
+ * Creates or overwrites files with optional LSP formatting and diagnostics.
+ */
+export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails> {
+    #private;
+    private readonly session;
+    readonly name = "write";
+    readonly approval: (args: unknown) => ToolTier;
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    readonly label = "Write";
+    readonly description: string;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        path: string;
+        content: string;
+    }, {}>;
+    readonly strict = true;
+    readonly concurrency = "exclusive";
+    readonly loadMode = "essential";
+    /** Stream matchers should see the real file content, not its JSON-escaped argument encoding. */
+    matcherDigest(args: unknown): string | undefined;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, { path: rawPath, content }: WriteParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<WriteToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<WriteToolDetails>>;
+}
+interface WriteRenderArgs {
+    path?: string;
+    file_path?: string;
+    content?: string;
+}
+export declare const writeToolRenderer: {
+    renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
+    renderResult(result: {
+        content: Array<{
+            type: string;
+            text?: string;
+        }>;
+        details?: WriteToolDetails;
+        isError?: boolean;
+    }, options: RenderResultOptions, uiTheme: Theme, args?: WriteRenderArgs): Component;
+    mergeCallAndResult: boolean;
+};
+export {};

package/dist/types/tools/yield.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Result submission tool for subagent output.
+ *
+ * Subagents can call this tool incrementally or terminally depending on `type`.
+ */
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "jeopi-agent-core";
+import type { TSchema } from "jeopi-ai/types";
+import type { ToolSession } from ".";
+export interface YieldDetails {
+    /** Successful result payload, or omitted when `useLastTurn` requests last-turn extraction. */
+    data?: unknown;
+    status: "success" | "aborted";
+    error?: string;
+    /** Optional result section/classification supplied by the yield caller. */
+    type?: string | string[];
+    /** True when the caller intentionally omitted success data so the executor uses the last assistant turn. */
+    useLastTurn?: boolean;
+    /**
+     * Set when the yield tool exhausted its in-tool schema-retry budget
+     * (MAX_SCHEMA_RETRIES) and accepted the data anyway. Surfaced so the
+     * executor's post-mortem finalizer can honor the override instead of
+     * re-rejecting the same payload with `schema_violation` — keeping the
+     * subagent's acceptance and the parent's view of the result in lockstep.
+     */
+    schemaOverridden?: boolean;
+}
+export declare class YieldTool implements AgentTool<TSchema, YieldDetails> {
+    #private;
+    readonly name = "yield";
+    readonly approval: "read";
+    readonly label = "Submit Result";
+    readonly description: string;
+    readonly parameters: TSchema;
+    strict: boolean;
+    readonly intent: "omit";
+    lenientArgValidation: boolean;
+    constructor(session: ToolSession);
+    execute(_toolCallId: string, params: unknown, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<YieldDetails>, _context?: AgentToolContext): Promise<AgentToolResult<YieldDetails>>;
+}

package/dist/types/tts/downloader.d.ts

@@ -0,0 +1,20 @@
+export interface TtsDownloadProgress {
+    stage: string;
+    /** Integer 0–100 download percent when known. */
+    percent?: number;
+}
+/**
+ * Whether the selected local TTS model and the side Kokoro runtime are already
+ * present. transformers.js stores `main`-revision files at
+ * `<cacheDir>/<repo>/...`, so any `.onnx` weight under the repo dir means the
+ * model weights can load without a network fetch; the Kokoro package runtime is
+ * version-keyed separately and must also exist before setup can report ready.
+ */
+export declare function isTtsModelCached(modelKey: string): Promise<boolean>;
+/**
+ * Ensure the selected local TTS model is downloaded into the transformers.js
+ * cache (and warm in the worker), streaming integer-percent Hub progress. The
+ * worker resolves the request once every model file is cached. Returns `false`
+ * if the worker is unavailable or the download failed.
+ */
+export declare function downloadTtsModel(modelKey: string, onProgress?: (progress: TtsDownloadProgress) => void, signal?: AbortSignal): Promise<boolean>;

package/dist/types/tts/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./downloader";
+export * from "./models";
+export * from "./runtime";
+export * from "./tts-client";
+export * from "./tts-protocol";
+export * from "./tts-worker";
+export * from "./vocalizer";
+export * from "./wav";