@moureau/pipeflow 0.0.1

package/dist/types/conversations/orchestration/orchestrator/orchestrator.d.ts

@@ -0,0 +1,98 @@
+import type { Agent } from "../../../agents/agent.js";
+import type { Conversation } from "../../conversation/conversation.js";
+import type { Persistence } from "../../../persistence/persistence.js";
+import type { LLM } from "../../../providers/llm/types.js";
+import type { STT } from "../../../providers/stt/types.js";
+import type { TTS } from "../../../providers/tts/types.js";
+export interface OrchestratorOptions {
+    conversation: Conversation;
+    /**
+     * The agent driving the realtime loop. Omit it for transcription-only
+     * mode (audio in, turns and transcripts out — no LLM or TTS required).
+     */
+    agent?: Agent;
+    /** Defaults to the agent's LLM. */
+    llm?: LLM;
+    stt: STT;
+    /** Required when an agent is attached. */
+    tts?: TTS;
+    /** Used to rehydrate conversation history on start. */
+    persistence?: Persistence;
+    /** How long to wait for the application to resolve a tool call. */
+    toolTimeoutMs?: number;
+    /** Safety bound on tool-call round trips per generation. */
+    maxToolIterations?: number;
+    temperature?: number;
+    maxTokens?: number;
+}
+/**
+ * The realtime conversation state machine.
+ *
+ * Wires the conversation to the providers:
+ *
+ * ```text
+ * audio-in ──► STT ──► turn ──► LLM ──► TTS ──► audio-out
+ *                              │
+ *                              └─► tool-call ──► app resolves ──► resume
+ * ```
+ *
+ * Deltas stream to TTS immediately (so the agent can narrate while a tool
+ * runs), tool calls pause the generation until the application resolves
+ * them, and interruptions cancel the current generation — discarding any
+ * stale tool results or audio via a generation epoch.
+ */
+export declare class Orchestrator {
+    private readonly conversation;
+    private readonly agent;
+    private readonly llm;
+    private readonly stt;
+    private readonly tts;
+    private readonly persistence;
+    private readonly toolTimeoutMs;
+    private readonly maxToolIterations;
+    private readonly temperature;
+    private readonly maxTokens;
+    private started;
+    private generating;
+    private epoch;
+    private readonly unsubscribers;
+    private readonly sttSessions;
+    private readonly history;
+    private readonly toolWaiters;
+    private generationChain;
+    private speechChain;
+    private speechBuffer;
+    private pendingTurns;
+    private pendingGenerations;
+    private audioSequence;
+    private turnSequence;
+    constructor(options: OrchestratorOptions);
+    /**
+     * Attach to the conversation: rehydrate history from persistence and
+     * subscribe to conversation events.
+     */
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Resolve once every queued and in-flight turn and generation has
+     * finished processing. Useful for tests and graceful shutdown.
+     */
+    whenIdle(): Promise<void>;
+    private onAudioIn;
+    private onPartial;
+    private onFinal;
+    private processTurn;
+    private onInterrupt;
+    private onToolCallResult;
+    private onProviderError;
+    private queueGeneration;
+    private generate;
+    private runGeneration;
+    private resolveToolCalls;
+    private waitForToolResult;
+    private cancelToolWaiters;
+    private feedDelta;
+    private flushSpeech;
+    /** Synthesize a sentence and push the audio chunks out to the app. */
+    private speak;
+}

package/dist/types/conversations/transcription/index.d.ts

@@ -0,0 +1,2 @@
+export { Transcription, TranscriptEntry } from "./transcription.js";
+export type { TranscriptEntryInput, TranscriptSpeakerKind, } from "./transcription.js";

package/dist/types/conversations/transcription/transcription.d.ts

@@ -0,0 +1,59 @@
+import type { ConversationId } from "../types.js";
+export type TranscriptSpeakerKind = "participant" | "agent";
+export interface TranscriptEntryInput {
+    conversationId: ConversationId;
+    speaker: string;
+    speakerKind: TranscriptSpeakerKind;
+    text: string;
+    timestamp?: number;
+    sequence?: number;
+    id?: string;
+}
+/**
+ * A single line of a conversation transcript.
+ *
+ * `toString()` renders the entry as `speaker: text` so transcript arrays can
+ * be joined directly into a readable dump.
+ */
+export declare class TranscriptEntry {
+    readonly id: string;
+    readonly conversationId: ConversationId;
+    readonly speaker: string;
+    readonly speakerKind: TranscriptSpeakerKind;
+    readonly text: string;
+    readonly timestamp: number;
+    readonly sequence: number;
+    constructor(input: TranscriptEntryInput);
+    /** Rebuild an entry from plain (e.g. persisted) data. */
+    static fromPlain(plain: TranscriptEntry): TranscriptEntry;
+    toString(): string;
+}
+/**
+ * In-memory transcript state for a single conversation.
+ *
+ * Entries are appended in order and assigned monotonically increasing
+ * sequence numbers. The orchestrator appends entries as speech is finalized
+ * and generations complete; persistence mirrors these entries.
+ */
+export declare class Transcription {
+    private readonly conversationId;
+    private readonly entries;
+    private readonly ids;
+    private nextSequence;
+    constructor(conversationId: ConversationId);
+    get length(): number;
+    get isEmpty(): boolean;
+    /** Append a participant speech entry. */
+    appendSpeech(speaker: string, text: string, timestamp?: number): TranscriptEntry;
+    /** Append an agent generation entry. */
+    appendGeneration(agentName: string, text: string, timestamp?: number): TranscriptEntry;
+    append(input: Omit<TranscriptEntryInput, "conversationId" | "sequence" | "id"> & {
+        id?: string;
+        sequence?: number;
+    }): TranscriptEntry;
+    list(): TranscriptEntry[];
+    get(id: string): TranscriptEntry | null;
+    getBySequence(sequence: number): TranscriptEntry | null;
+    last(): TranscriptEntry | null;
+    clear(): void;
+}

package/dist/types/conversations/types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Core domain types shared across Pipeflow modules.
+ */
+export type ConversationId = string;
+export type UserId = string;
+export type TurnId = string;
+export interface ParticipantInput {
+    userId: UserId;
+    aliases?: string[];
+}
+export interface Participant {
+    userId: UserId;
+    aliases: string[];
+    joinedAt: number;
+}
+export interface Turn {
+    id: TurnId;
+    conversationId: ConversationId;
+    participantId: UserId;
+    participantName: string;
+    text: string;
+    sequence: number;
+    startedAt: number;
+    endedAt: number;
+}
+export type GenerationStatus = "streaming" | "completed" | "cancelled";
+export interface Generation {
+    id: string;
+    conversationId: ConversationId;
+    agentName: string;
+    text: string;
+    status: GenerationStatus;
+    startedAt: number;
+    endedAt?: number;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    /** Parsed arguments, or the raw JSON string if parsing failed. */
+    arguments: unknown;
+}
+export type ToolCallResult = {
+    id: string;
+    result: unknown;
+} | {
+    id: string;
+    error: string;
+};
+export interface AudioChunk {
+    data: Uint8Array;
+    timestamp: number;
+    sequence: number;
+}
+export type ConversationStatus = "created" | "started" | "stopped";
+export interface ConversationState {
+    status: ConversationStatus;
+    participants: Map<UserId, Participant>;
+    floor: UserId | null;
+    currentTurn: Turn | null;
+    currentGeneration: Generation | null;
+    transcriptCount: number;
+}
+export declare function createConversationState(status?: ConversationStatus): ConversationState;

package/dist/types/index.d.ts

@@ -0,0 +1,45 @@
+import { Agent, type AgentOptions } from "./agents/agent.js";
+import { Conversations } from "./conversations/conversations.js";
+import type { Persistence } from "./persistence/persistence.js";
+import type { LLM } from "./providers/llm/types.js";
+import type { STT } from "./providers/stt/types.js";
+import type { TTS } from "./providers/tts/types.js";
+export interface PipeflowOptions {
+    llm?: LLM;
+    stt?: STT;
+    tts?: TTS;
+    persistence?: Persistence;
+}
+/**
+ * The Pipeflow entry point.
+ *
+ * ```ts
+ * const pipeflow = new Pipeflow({ llm });
+ * const agent = pipeflow.agent({ name: "Jarvis", context: "..." });
+ * const conversation = await pipeflow.conversations.create({ agents: [agent] });
+ * ```
+ */
+export declare class Pipeflow {
+    readonly llm: LLM | undefined;
+    readonly stt: STT | undefined;
+    readonly tts: TTS | undefined;
+    readonly conversations: Conversations;
+    constructor(options?: PipeflowOptions);
+    /**
+     * Create an agent. Agents inherit the Pipeflow instance's LLM provider so
+     * `agent.run()` works out of the box.
+     */
+    agent(options: Omit<AgentOptions, "llm"> & {
+        llm?: LLM;
+    }): Agent;
+}
+export { Agent };
+export type { AgentOptions, AgentRunRequest, AgentRunResult, ExecutedToolCall, } from "./agents/agent.js";
+export { Tool, Tool as PipeflowTool } from "./agents/tools/tools.js";
+export type { ToolOptions } from "./agents/tools/tools.js";
+export { Conversation, Conversations, Orchestrator, Transcription, TranscriptEntry, } from "./conversations/index.js";
+export type { AudioChunk, ConversationEvents, ConversationId, ConversationOptions, ConversationState, ConversationStatus, CreateConversationOptions, Generation, GenerationStatus, OrchestratorOptions, Participant, ParticipantInput, ToolCall, ToolCallResult, TranscriptEntryInput, TranscriptSpeakerKind, Turn, TurnId, UserId, } from "./conversations/index.js";
+export type { LLM, LLMMessage } from "./providers/llm/types.js";
+export type { STT } from "./providers/stt/types.js";
+export type { TTS } from "./providers/tts/types.js";
+export type { Persistence } from "./persistence/persistence.js";

package/dist/types/persistence/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export { MemoryPersistence } from "./memory/memory.js";
+export { SQLitePersistence } from "./sqlite/sqlite.js";

package/dist/types/persistence/adapters/memory/index.d.ts

@@ -0,0 +1 @@
+export { MemoryPersistence } from "./memory.js";

package/dist/types/persistence/adapters/memory/memory.d.ts

@@ -0,0 +1,27 @@
+import type { ConversationId, Generation, Participant, Turn } from "../../../conversations/types.js";
+import type { TranscriptEntry } from "../../../conversations/transcription/transcription.js";
+import type { ConversationRecord, NewConversation, Persistence } from "../../persistence.js";
+/**
+ * In-memory persistence adapter. Useful for tests and development: data is
+ * lost when the process exits.
+ */
+export declare class MemoryPersistence implements Persistence {
+    private readonly conversations;
+    private readonly participants;
+    private readonly transcript;
+    private readonly turns;
+    private readonly generations;
+    createConversation(input?: NewConversation): Promise<ConversationRecord>;
+    getConversation(id: ConversationId): Promise<ConversationRecord | null>;
+    listConversations(): Promise<ConversationRecord[]>;
+    finalizeConversation(id: ConversationId, endedAt?: number): Promise<ConversationRecord | null>;
+    deleteConversation(id: ConversationId): Promise<boolean>;
+    addParticipant(conversationId: ConversationId, participant: Participant): Promise<void>;
+    listParticipants(conversationId: ConversationId): Promise<Participant[]>;
+    appendTranscript(conversationId: ConversationId, entry: TranscriptEntry): Promise<void>;
+    listTranscript(conversationId: ConversationId): Promise<TranscriptEntry[]>;
+    appendTurn(conversationId: ConversationId, turn: Turn): Promise<void>;
+    listTurns(conversationId: ConversationId): Promise<Turn[]>;
+    appendGeneration(conversationId: ConversationId, generation: Generation): Promise<void>;
+    listGenerations(conversationId: ConversationId): Promise<Generation[]>;
+}

package/dist/types/persistence/adapters/sqlite/index.d.ts

@@ -0,0 +1,2 @@
+export { SQLitePersistence } from "./sqlite.js";
+export type { SQLitePersistenceOptions } from "./sqlite.js";

package/dist/types/persistence/adapters/sqlite/sqlite.d.ts

@@ -0,0 +1,31 @@
+import type { ConversationId, Generation, Participant, Turn } from "../../../conversations/types.js";
+import { TranscriptEntry } from "../../../conversations/transcription/transcription.js";
+import type { ConversationRecord, NewConversation, Persistence } from "../../persistence.js";
+export interface SQLitePersistenceOptions {
+    /** Database filename. Defaults to an in-memory database. */
+    filename?: string;
+}
+/**
+ * SQLite-backed persistence adapter (via bun:sqlite).
+ *
+ * A lightweight persistent backend for local applications and early
+ * deployments.
+ */
+export declare class SQLitePersistence implements Persistence {
+    private readonly db;
+    constructor(options?: SQLitePersistenceOptions);
+    close(): void;
+    createConversation(input?: NewConversation): Promise<ConversationRecord>;
+    getConversation(id: ConversationId): Promise<ConversationRecord | null>;
+    listConversations(): Promise<ConversationRecord[]>;
+    finalizeConversation(id: ConversationId, endedAt?: number): Promise<ConversationRecord | null>;
+    deleteConversation(id: ConversationId): Promise<boolean>;
+    addParticipant(conversationId: ConversationId, participant: Participant): Promise<void>;
+    listParticipants(conversationId: ConversationId): Promise<Participant[]>;
+    appendTranscript(conversationId: ConversationId, entry: TranscriptEntry): Promise<void>;
+    listTranscript(conversationId: ConversationId): Promise<TranscriptEntry[]>;
+    appendTurn(conversationId: ConversationId, turn: Turn): Promise<void>;
+    listTurns(conversationId: ConversationId): Promise<Turn[]>;
+    appendGeneration(conversationId: ConversationId, generation: Generation): Promise<void>;
+    listGenerations(conversationId: ConversationId): Promise<Generation[]>;
+}

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

@@ -0,0 +1,2 @@
+export type { ConversationRecord, NewConversation, Persistence, } from "./persistence.js";
+export { MemoryPersistence, SQLitePersistence } from "./adapters/index.js";

package/dist/types/persistence/persistence.d.ts

@@ -0,0 +1,38 @@
+import type { ConversationId, Generation, Participant, Turn, UserId } from "../conversations/types.js";
+import type { TranscriptEntry } from "../conversations/transcription/transcription.js";
+export interface ConversationRecord {
+    id: ConversationId;
+    agentNames: string[];
+    createdAt: number;
+    endedAt: number | null;
+}
+export interface NewConversation {
+    id?: ConversationId;
+    agentNames?: string[];
+    createdAt?: number;
+}
+/**
+ * Storage contract for the conversation domain.
+ *
+ * Persistence is provider-independent: memory and SQLite are the built-in
+ * adapters, and other backends can implement the same interface.
+ */
+export interface Persistence {
+    createConversation(input?: NewConversation): Promise<ConversationRecord>;
+    getConversation(id: ConversationId): Promise<ConversationRecord | null>;
+    listConversations(): Promise<ConversationRecord[]>;
+    /** Mark a conversation as ended. Returns null if it does not exist. */
+    finalizeConversation(id: ConversationId, endedAt?: number): Promise<ConversationRecord | null>;
+    deleteConversation(id: ConversationId): Promise<boolean>;
+    addParticipant(conversationId: ConversationId, participant: Participant): Promise<void>;
+    listParticipants(conversationId: ConversationId): Promise<Participant[]>;
+    /** Upsert a transcript entry (entries are immutable in practice). */
+    appendTranscript(conversationId: ConversationId, entry: TranscriptEntry): Promise<void>;
+    listTranscript(conversationId: ConversationId): Promise<TranscriptEntry[]>;
+    appendTurn(conversationId: ConversationId, turn: Turn): Promise<void>;
+    listTurns(conversationId: ConversationId): Promise<Turn[]>;
+    /** Upsert a generation so status updates (e.g. completed) overwrite. */
+    appendGeneration(conversationId: ConversationId, generation: Generation): Promise<void>;
+    listGenerations(conversationId: ConversationId): Promise<Generation[]>;
+}
+export type { ConversationId, UserId };

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

@@ -0,0 +1,6 @@
+export type { LLM, LLMEvent, LLMMessage, LLMRole, LLMToolCall, LLMToolDefinition, LLMRequest } from "./llm/index.js";
+export type { STT, STTOptions, STTSession } from "./stt/index.js";
+export type { TTS, TTSRequest } from "./tts/index.js";
+export { complete, streamText, DeepSeekLLM } from "./llm/index.js";
+export { DeepgramSTT } from "./stt/index.js";
+export { KokoroTTS } from "./tts/index.js";

package/dist/types/providers/llm/adapters/deepseek/deepseek.d.ts

@@ -0,0 +1,24 @@
+import type { LLM, LLMEvent, LLMRequest } from "../../types.js";
+import type { FetchLike } from "../../../shared.js";
+export interface DeepSeekOptions {
+    apiKey: string;
+    /** Defaults to `deepseek-chat`. */
+    model?: string;
+    /** Defaults to `https://api.deepseek.com`. */
+    baseUrl?: string;
+    /** Injectable fetch implementation, mainly for tests. */
+    fetch?: FetchLike;
+}
+/**
+ * DeepSeek LLM adapter (OpenAI-compatible chat completions over SSE).
+ */
+export declare class DeepSeekLLM implements LLM {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private abort;
+    constructor(options: DeepSeekOptions);
+    stop(): void;
+    stream(request: LLMRequest): AsyncGenerator<LLMEvent>;
+}

package/dist/types/providers/llm/adapters/deepseek/index.d.ts

@@ -0,0 +1,2 @@
+export { DeepSeekLLM } from "./deepseek.js";
+export type { DeepSeekOptions } from "./deepseek.js";

package/dist/types/providers/llm/adapters/index.d.ts

@@ -0,0 +1 @@
+export { DeepSeekLLM } from "./deepseek/deepseek.js";

package/dist/types/providers/llm/index.d.ts

@@ -0,0 +1,10 @@
+import type { LLM, LLMRequest } from "./types.js";
+export type { LLM, LLMEvent, LLMMessage, LLMRole, LLMToolCall, LLMToolDefinition, LLMRequest, } from "./types.js";
+/**
+ * Stream only the text deltas of an LLM generation, rethrowing any
+ * streamed error.
+ */
+export declare function streamText(llm: LLM, request: LLMRequest): AsyncGenerator<string>;
+/** Collect an entire LLM generation into a single string. */
+export declare function complete(llm: LLM, request: LLMRequest): Promise<string>;
+export { DeepSeekLLM } from "./adapters/index.js";

package/dist/types/providers/llm/types.d.ts

@@ -0,0 +1,55 @@
+export type LLMRole = "system" | "user" | "assistant" | "tool";
+export interface LLMToolCall {
+    id: string;
+    name: string;
+    /** JSON-encoded arguments for the tool. */
+    arguments: string;
+}
+export interface LLMMessage {
+    role: LLMRole;
+    content: string;
+    /** Tool name, for `tool` role messages. */
+    name?: string;
+    /** Tool call id this message answers, for `tool` role messages. */
+    toolCallId?: string;
+    /** Tool calls announced by the assistant, for `assistant` role messages. */
+    toolCalls?: LLMToolCall[];
+}
+export interface LLMToolDefinition {
+    name: string;
+    description: string;
+    /** JSON schema describing the tool arguments. */
+    parameters: Record<string, unknown>;
+}
+export interface LLMRequest {
+    messages: LLMMessage[];
+    tools?: LLMToolDefinition[];
+    temperature?: number;
+    maxTokens?: number;
+}
+export type LLMEvent = {
+    type: "delta";
+    content: string;
+} | {
+    type: "tool_call";
+    id: string;
+    name: string;
+    arguments: string;
+} | {
+    type: "done";
+} | {
+    type: "error";
+    error: Error;
+};
+/**
+ * Vendor-independent language model interface.
+ *
+ * `stream()` produces deltas as they arrive plus optional tool calls, and
+ * terminates with `done`. Transport-level failures (network, HTTP status)
+ * are thrown from the generator rather than emitted.
+ */
+export interface LLM {
+    stream(request: LLMRequest): AsyncGenerator<LLMEvent>;
+    /** Cancel the currently in-flight generation, if any. */
+    stop(): void;
+}

package/dist/types/providers/shared.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The fetch surface used by provider adapters.
+ *
+ * Defined separately from `typeof fetch` because Bun's fetch adds static
+ * members (e.g. `preconnect`) that plain functions cannot satisfy, which
+ * makes test doubles awkward.
+ */
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;

package/dist/types/providers/stt/adapters/deepgram/deepgram.d.ts

@@ -0,0 +1,57 @@
+import type { STT, STTOptions, STTSession } from "../../types.js";
+/**
+ * The minimal WebSocket surface used by the Deepgram adapter. Both the global
+ * `WebSocket` (Bun) and test fakes satisfy this shape.
+ */
+export interface STTSocket {
+    send(data: string | ArrayBuffer | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: (event: {
+        data?: unknown;
+        error?: unknown;
+    }) => void): void;
+}
+export interface DeepgramOptions extends STTOptions {
+    apiKey: string;
+    /** Defaults to `wss://api.deepgram.com/v1/listen`. */
+    endpoint?: string;
+    /** Injectable socket factory, mainly for tests. */
+    createSocket?: (url: string) => STTSocket;
+}
+/**
+ * Deepgram streaming STT adapter (WebSocket).
+ *
+ * Audio written before the socket opens is queued and flushed on connect.
+ * `end()` sends a `CloseStream` frame and resolves once the server closes
+ * the socket.
+ */
+export declare class DeepgramSTT implements STT {
+    private readonly options;
+    private readonly sessions;
+    constructor(options: DeepgramOptions);
+    start(options?: STTOptions): STTSession;
+    cancel(): void;
+}
+export declare class DeepgramSession implements STTSession {
+    private readonly socket;
+    private readonly listeners;
+    private opened;
+    private closed;
+    private ended;
+    private readonly pendingClose;
+    private readonly queued;
+    private readonly endPromise;
+    private resolveEnd;
+    constructor(socket: STTSocket);
+    write(audio: Uint8Array): void;
+    end(): Promise<void>;
+    /** Force-close the session without waiting for the server. */
+    abort(): void;
+    on(event: "partial", listener: (transcript: string) => void): void;
+    on(event: "final", listener: (transcript: string) => void): void;
+    on(event: "error", listener: (error: Error) => void): void;
+    on(event: "close", listener: () => void): void;
+    private handleResult;
+    private sendCloseStream;
+    private emit;
+}

package/dist/types/providers/stt/adapters/deepgram/index.d.ts

@@ -0,0 +1,2 @@
+export { DeepgramSTT, DeepgramSession } from "./deepgram.js";
+export type { DeepgramOptions, STTSocket } from "./deepgram.js";

package/dist/types/providers/stt/adapters/index.d.ts

@@ -0,0 +1 @@
+export { DeepgramSTT } from "./deepgram/deepgram.js";

package/dist/types/providers/stt/index.d.ts

@@ -0,0 +1,2 @@
+export type { STT, STTOptions, STTSession } from "./types.js";
+export { DeepgramSTT } from "./adapters/index.js";

package/dist/types/providers/stt/types.d.ts

@@ -0,0 +1,30 @@
+export interface STTOptions {
+    model?: string;
+    language?: string;
+    /** Whether interim (partial) transcripts are reported. */
+    interimResults?: boolean;
+    /** Audio encoding, e.g. `linear16`. */
+    encoding?: string;
+    /** Audio sample rate in Hz. */
+    sampleRate?: number;
+}
+export interface STTSession {
+    /** Feed an audio chunk into the recognizer. */
+    write(audio: Uint8Array): void;
+    /** Signal the end of the audio stream and wait for the session to close. */
+    end(): Promise<void>;
+    on(event: "partial", listener: (transcript: string) => void): void;
+    on(event: "final", listener: (transcript: string) => void): void;
+    on(event: "error", listener: (error: Error) => void): void;
+}
+/**
+ * Vendor-independent speech-to-text interface.
+ *
+ * `start()` opens a streaming session; audio is fed in with `write()` and
+ * transcripts are reported via `partial`/`final` events.
+ */
+export interface STT {
+    start(options?: STTOptions): STTSession;
+    /** Cancel all active sessions. */
+    cancel(): void;
+}

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

@@ -0,0 +1 @@
+export { KokoroTTS } from "./kokoro/kokoro.js";

package/dist/types/providers/tts/adapters/kokoro/index.d.ts

@@ -0,0 +1,2 @@
+export { KokoroTTS } from "./kokoro.js";
+export type { KokoroOptions } from "./kokoro.js";

package/dist/types/providers/tts/adapters/kokoro/kokoro.d.ts

@@ -0,0 +1,34 @@
+import type { TTS, TTSRequest } from "../../types.js";
+import type { FetchLike } from "../../../shared.js";
+export interface KokoroOptions {
+    /**
+     * Base URL of a Kokoro TTS server exposing the OpenAI-compatible
+     * `/v1/audio/speech` endpoint. Defaults to a local kokoro-fastapi server.
+     */
+    baseUrl?: string;
+    /** Default voice, e.g. `af_heart`. */
+    voice?: string;
+    model?: string;
+    apiKey?: string;
+    /** Size of the audio chunks yielded from the response stream. */
+    chunkSize?: number;
+    /** Injectable fetch implementation, mainly for tests. */
+    fetch?: FetchLike;
+}
+/**
+ * Kokoro TTS adapter. Consumes a Kokoro server's OpenAI-compatible speech
+ * endpoint and re-chunks the returned audio so it can be played as it
+ * arrives.
+ */
+export declare class KokoroTTS implements TTS {
+    private readonly baseUrl;
+    private readonly voice;
+    private readonly model;
+    private readonly apiKey;
+    private readonly chunkSize;
+    private readonly fetchImpl;
+    private abort;
+    constructor(options?: KokoroOptions);
+    stop(): void;
+    stream(request: TTSRequest): AsyncGenerator<Uint8Array>;
+}

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

@@ -0,0 +1,2 @@
+export type { TTS, TTSRequest } from "./types.js";
+export { KokoroTTS } from "./adapters/index.js";