@moureau/pipeflow 0.0.1 → 0.0.3

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

@@ -0,0 +1,78 @@
+import type { Conversation } from "../../../conversation/conversation.js";
+import type { TTS } from "../../../../providers/tts/types.js";
+export interface SpeechPipelineOptions {
+    /** TTS provider; omitted for text-only conversations. */
+    tts?: TTS;
+    conversation: Conversation;
+    /**
+     * True while the generation that produced the speech is still current.
+     * The captured generation epoch is passed back in, so an interrupt (epoch
+     * bump) or a stop drops queued and in-flight synthesis.
+     */
+    isCurrent(epoch: number): boolean;
+    /**
+     * How many synthesis requests may be in flight at once. Sentences are
+     * started as soon as a slot is free — the next one synthesizes while the
+     * current one is still streaming — so playback never waits for the whole
+     * reply, but a burst of many sentences can't flood the provider (free TTS
+     * variants rate-limit concurrent requests). Default 2.
+     */
+    maxConcurrentRequests?: number;
+}
+/**
+ * Turns the LLM delta stream into speakable audio: expose the text stream
+ * semantically (`text-delta`), buffer sentences through the `TextChunker`,
+ * and synthesize each chunk through the TTS provider on a serial chain.
+ *
+ * Owns the chunker, the speech epoch (bumped by `stop()`), the synthesis
+ * chain, and the audio sequence — the orchestrator only decides *when*
+ * speech is current.
+ */
+export declare class SpeechPipeline {
+    private readonly tts;
+    private readonly conversation;
+    private readonly isCurrent;
+    private readonly maxConcurrent;
+    private readonly chunker;
+    private speechEpoch;
+    private chain;
+    private audioSequence;
+    /** Flushed sentences still waiting for a synthesis slot. */
+    private readonly queue;
+    /** Synthesis requests started but not yet fully delivered. */
+    private inFlight;
+    constructor(options: SpeechPipelineOptions);
+    /**
+     * Stream an LLM delta to the application and the TTS pipeline. Empty
+     * deltas (reasoning-only frames) are skipped so they never reach the
+     * text-delta event or the chunker.
+     */
+    feed(delta: string, epoch: number): void;
+    /** Speak any remaining buffered text as a final chunk. */
+    flush(epoch: number): void;
+    /**
+     * Queue a sentence for synthesis, starting it if a slot is free. The text
+     * order is preserved end to end: requests start in flush order, and delivery
+     * below is serialized through `chain`, so sentence N never overtakes N-1.
+     */
+    speak(sentence: string, epoch: number): void;
+    /**
+     * Start synthesis for queued sentences up to the concurrency bound. A
+     * sentence's request is fired as soon as a slot is free — while the previous
+     * sentence is still streaming/playing — so the first piece is ready first
+     * and later pieces overlap it, without ever flooding the provider with one
+     * request per sentence of a long reply.
+     */
+    private startNext;
+    /**
+     * Stop the current TTS playback and drop buffered text without cancelling
+     * the generation (barge-in, interrupt, stop).
+     */
+    stop(): void;
+    /**
+     * Resolve when every queued and in-flight sentence has been synthesized and
+     * delivered. Unlike the delivery chain alone, this also waits for sentences
+     * still waiting on a synthesis slot.
+     */
+    waitForIdle(): Promise<void>;
+}

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

@@ -0,0 +1,2 @@
+export { ToolCallManager } from "./tools.js";
+export type { ResolvedToolCall } from "./tools.js";

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

@@ -0,0 +1,65 @@
+import type { Conversation } from "../../../conversation/conversation.js";
+import type { LLMToolCall } from "../../../../providers/llm/types.js";
+import type { ToolCallResult } from "../../../types.js";
+import type { Tool } from "../../../../agents/tools/tools.js";
+export interface ResolvedToolCall {
+    id: string;
+    name: string;
+    result?: unknown;
+    error?: string;
+}
+export interface ToolCallManagerOptions {
+    /**
+     * The tools the framework can execute on the agent's behalf, keyed by
+     * name. Built from the orchestrated agents' tool registries.
+     */
+    tools?: ReadonlyMap<string, Tool<never, unknown>>;
+    /**
+     * Execute tool calls automatically (default `true`), feeding each tool's
+     * result — or a caught error — back into the model loop. Set `false` to
+     * keep the application-managed contract: listen for `tool-call`, execute
+     * the tool in your own backend, and report back with
+     * `resolveToolCall()`. `tool-call` events are still emitted for
+     * visibility in either mode.
+     */
+    autoExecute?: boolean;
+}
+/**
+ * Resolves the tool calls a generation issues. By default it runs the
+ * matching tool itself (the conversation agents' tools auto-execute, exactly
+ * like `Agent.run()`); with `autoExecute: false` it hands the calls to the
+ * application and resolves them once the application reports back (or a
+ * timeout fires). Stale results — timed out, already resolved, or superseded
+ * by an interrupt — are dropped.
+ */
+export declare class ToolCallManager {
+    private readonly conversation;
+    private readonly timeoutMs;
+    private readonly tools;
+    private readonly autoExecute;
+    private readonly waiters;
+    constructor(conversation: Conversation, timeoutMs: number, options?: ToolCallManagerOptions);
+    /**
+     * Resolve a batch of tool calls. In auto-execute mode each call's tool
+     * runs on the agent's behalf (errors caught and returned to the model);
+     * otherwise the application resolves them. Either way the calls are
+     * emitted as `tool-call` events and resolved in call order, with either a
+     * result or an error string.
+     */
+    resolveCalls(calls: LLMToolCall[]): Promise<ResolvedToolCall[]>;
+    /** Resolve a waiter from a `tool-call-result` event; stale results drop. */
+    handleResult(result: ToolCallResult): void;
+    /** Force-resolve every pending call (interrupt, stop). */
+    cancelAll(reason: string): void;
+    /**
+     * Execute one tool call and resolve it with the tool's result (or a
+     * caught error). If the application already resolved the call in its
+     * `tool-call` handler — the app-managed path — the tool is not run twice.
+     */
+    private runToolAndResolve;
+    /** Resolve through the conversation only while the call is still pending. */
+    private resolveIfPending;
+    private isPending;
+    private parseArguments;
+    private wait;
+}

package/dist/types/conversations/orchestration/test-harness.d.ts

@@ -0,0 +1,100 @@
+import { Tool } from "../../agents/tools/tools.js";
+import { Conversation } from "../conversation/conversation.js";
+import { MemoryPersistence } from "../../persistence/adapters/memory/memory.js";
+import { Orchestrator } from "./orchestrator/orchestrator.js";
+import type { HistoryWindow } from "./orchestrator/history/history.js";
+import type { LLM, LLMEvent, LLMRequest } from "../../providers/llm/types.js";
+import type { STT, STTOptions, STTSession } from "../../providers/stt/types.js";
+import type { TTS, TTSRequest } from "../../providers/tts/types.js";
+export type LLMScript = (request: LLMRequest, signal: AbortSignal) => AsyncIterable<LLMEvent>;
+export declare class FakeLLM implements LLM {
+    private readonly script;
+    readonly requests: LLMRequest[];
+    readonly stopCalls: number[];
+    private readonly controllers;
+    constructor(script: LLMScript);
+    stream(request: LLMRequest): AsyncGenerator<LLMEvent>;
+    stop(): void;
+}
+export declare class FakeSTT implements STT {
+    readonly sessions: FakeSTTSession[];
+    readonly startOptions: STTOptions[];
+    start(options?: STTOptions): FakeSTTSession;
+    cancel(): void;
+}
+export type FakeSessionEvent = "partial" | "final" | "error";
+export declare class FakeSTTSession implements STTSession {
+    readonly written: Uint8Array[];
+    ended: number;
+    private readonly listeners;
+    write(audio: Uint8Array): void;
+    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;
+    emitPartial(text: string): void;
+    emitFinal(text: string): void;
+    emitError(error: Error): void;
+}
+export declare class FakeTTS implements TTS {
+    private readonly chunksFor;
+    readonly requests: TTSRequest[];
+    private readonly controllers;
+    constructor(chunksFor: (text: string) => Uint8Array[]);
+    stream(request: TTSRequest): AsyncGenerator<Uint8Array>;
+    stop(): void;
+}
+/**
+ * A TTS that streams one chunk at a time with a delay, so audio is still
+ * mid-flight when an interrupt arrives.
+ */
+export declare class SlowTTS implements TTS {
+    private readonly chunksFor;
+    private readonly delayMs;
+    readonly requests: TTSRequest[];
+    private readonly controllers;
+    constructor(chunksFor: (text: string) => Uint8Array[], delayMs?: number);
+    stream(request: TTSRequest): AsyncGenerator<Uint8Array>;
+    stop(): void;
+}
+export type TtsHarness = FakeTTS | SlowTTS;
+export interface Harness {
+    conversation: Conversation;
+    orchestrator: Orchestrator;
+    llm: FakeLLM;
+    stt: FakeSTT;
+    tts: TtsHarness;
+    persistence: MemoryPersistence;
+}
+export declare function setup(options: {
+    script: LLMScript;
+    ttsChunks?: (text: string) => Uint8Array[];
+    tts?: TtsHarness;
+    tools?: Tool<never, unknown>[];
+    toolTimeoutMs?: number;
+    context?: string;
+    /** Inject a real LLM (e.g. an adapter over a mocked fetch) instead of a scripted fake. */
+    llm?: LLM;
+    /** Override the conversation-history window (default 5 turns / 4k chars). */
+    historyWindow?: HistoryWindow | false;
+    /** Auto-execute the agent's tools (default true); see OrchestratorOptions. */
+    autoExecuteTools?: boolean;
+}): Promise<Harness>;
+export declare function waitFor(condition: () => boolean, timeoutMs?: number): Promise<void>;
+export declare function speak(harness: Harness, userId: string, text: string): Promise<void>;
+export declare function respond(text: string): LLMScript;
+export type RosterHarness = Harness & {
+    llms: Map<string, FakeLLM>;
+};
+export declare function setupRoster(options: {
+    coordinatorScript: LLMScript;
+    scripts: Record<string, LLMScript>;
+    tools?: Record<string, Tool<never, unknown>[]>;
+    coordinations?: Record<string, {
+        prompt: string;
+        llm: FakeLLM;
+    }>;
+    maxCoordinationSteps?: number;
+    /** Auto-execute the agents' tools (default true); see OrchestratorOptions. */
+    autoExecuteTools?: boolean;
+}): Promise<RosterHarness>;

package/dist/types/conversations/orchestration/text-chunker/index.d.ts

@@ -0,0 +1 @@
+export * from './text-chunker.js';

package/dist/types/conversations/orchestration/text-chunker/text-chunker.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Streaming text segmenter for speech.
+ *
+ * Turns an incremental LLM token stream into speakable chunks with a boundary
+ * hierarchy, so TTS never waits indefinitely for punctuation:
+ *
+ * 1. **Strong boundary** — `. ! ? \n` flush immediately (sentence end).
+ * 2. **Soft boundary** — once the buffer is long enough, split at the last
+ *    `, ; :` that yields a chunk of at least `minSoftLength` characters.
+ * 3. **Hard cap** — at `maxLength` the buffer flushes regardless of
+ *    punctuation.
+ *
+ * The heuristics are intentionally internal and benchmark-driven rather than
+ * configurable through the public API.
+ */
+export interface TextChunkerOptions {
+    /** Buffer length at which a soft boundary becomes eligible. Default 80. */
+    targetLength?: number;
+    /** Hard cap before an unconditional flush. Default 140. */
+    maxLength?: number;
+    /** Smallest chunk a soft boundary may produce. Default 40. */
+    minSoftLength?: number;
+}
+export declare class TextChunker {
+    private readonly targetLength;
+    private readonly maxLength;
+    private readonly minSoftLength;
+    private buffer;
+    constructor(options?: TextChunkerOptions);
+    /** Feed tokens; returns zero or more complete chunks to synthesize. */
+    push(delta: string): string[];
+    /** Flush any remaining buffered text as a final chunk (or null). */
+    flush(): string | null;
+    /** Drop the buffer (interrupt, stop). */
+    clear(): void;
+    private takeNext;
+    /** Cut the buffer through index `i` (inclusive) and return the text. */
+    private takeThrough;
+}

package/dist/types/conversations/stream/conversation-stream.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ConversationStream — the conversation's semantic reply stream.
+ *
+ * Turns a Conversation's event stream (LLM text fragments + generation
+ * completion) into FieldStream completion events: consumers act on partial
+ * reply text without waiting for the reply to finish.
+ *
+ *   const replies = new ConversationStream(conversation);
+ *   replies.whenItem("text", (fragment, i) => render(fragment));
+ *   replies.when("agent", (agent) => showSpeaker(agent));
+ *   replies.whenObjectDone((reply) => finalize(reply));
+ *   replies.cancel(); // aborts the current generation (interrupts the LLM)
+ *
+ * One semantic object per top-level generation (agent or coordination
+ * reply). The `text` field is an ordered sequence of completed text
+ * fragments — semantically "the next fragment of the reply arrived", not
+ * "whatever happened to be inside a provider SSE packet". Fragment sizes are
+ * an implementation detail of the producer and may be coalesced later.
+ *
+ * Lifecycle per reply:
+ *
+ *   first fragment ──▶ STREAMING ──generation-complete──▶ DONE
+ *                          ├──cancel()/interrupt──▶ CANCELLED
+ *                          └──provider error──────▶ FAILED
+ *
+ * Each boundary fires at most once; no completion event fires after a
+ * terminal state. Interruptions and errors leave already-delivered fragments
+ * as valid partial state. Delegated sub-generation results do not terminate
+ * the top-level reply — only the top-level generation's completion does.
+ */
+import { FieldStream } from "../../transport/streamobject/field-stream/field-stream.js";
+import type { Conversation } from "../conversation/conversation.js";
+export declare class ConversationStream extends FieldStream {
+    private readonly unsubscribers;
+    private active;
+    constructor(conversation: Conversation);
+    /** Stop listening to the conversation. */
+    dispose(): void;
+    private onDelta;
+    private completeReply;
+    private abortReply;
+}

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

@@ -0,0 +1 @@
+export { ConversationStream } from "./conversation-stream.js";

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

@@ -24,6 +24,29 @@ export interface Turn {
     endedAt: number;
 }
 export type GenerationStatus = "streaming" | "completed" | "cancelled";
+/**
+ * Latency instrumentation for a generation. Times are epoch milliseconds;
+ * only `startedAt` is always present. The chain distinguishes each hop:
+ *
+ * ```text
+ * turn → first LLM token → first TTS text (buffering flush)
+ *     → TTS requested → TTS first audio → audio delivered → completed
+ * ```
+ */
+export interface GenerationTiming {
+    startedAt: number;
+    /** First LLM delta of this generation (first-token latency). */
+    firstTokenAt?: number;
+    /** First sentence flushed to TTS (text buffering latency). */
+    firstTtsTextAt?: number;
+    /** First TTS stream request issued (queue latency). */
+    firstTtsRequestAt?: number;
+    /** First audio chunk produced by the TTS provider (provider latency). */
+    firstTtsAudioAt?: number;
+    /** First TTS audio chunk delivered to the application (transport latency). */
+    firstAudioAt?: number;
+    completedAt?: number;
+}
 export interface Generation {
     id: string;
     conversationId: ConversationId;
@@ -32,6 +55,15 @@ export interface Generation {
     status: GenerationStatus;
     startedAt: number;
     endedAt?: number;
+    /**
+     * "sub" marks a task dispatched to another agent by the coordinator.
+     * Regular agent replies omit this field.
+     */
+    kind?: "sub";
+    /** For sub-generations: the id of the coordinator generation that dispatched them. */
+    parentGenerationId?: string;
+    /** Latency instrumentation, recorded as the generation streams. */
+    timing?: GenerationTiming;
 }
 export interface ToolCall {
     id: string;

package/dist/types/index.d.ts

@@ -1,44 +1,11 @@
-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 { Pipeflow } from "./pipeflow.js";
+export type { PipeflowOptions } from "./pipeflow.js";
+export { Agent } from "./agents/agent.js";
 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 { Conversation, Conversations, Transcription, TranscriptEntry, } from "./conversations/index.js";
+export type { AudioChunk, ConversationEvents, ConversationId, ConversationOptions, ConversationState, ConversationStatus, CreateConversationOptions, Generation, GenerationStatus, 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";

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

@@ -0,0 +1,2 @@
+export { Pipeflow } from "./pipeflow.js";
+export type { PipeflowOptions } from "./pipeflow.js";

package/dist/types/pipeflow/pipeflow.d.ts

@@ -0,0 +1,43 @@
+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;
+    /**
+     * Default for created conversations: auto-execute the agents' tools
+     * (default `true`), feeding each tool's result back into the model loop.
+     * Set `false` to resolve tool calls from your own backend via
+     * `resolveToolCall()`. Override per conversation in
+     * `pipeflow.conversations.create()`.
+     */
+    autoExecuteTools?: boolean;
+}
+/**
+ * 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;
+}

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

@@ -1,6 +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 { complete, streamText, DeepSeekLLM, OpenRouterLLM } from "./llm/index.js";
 export { DeepgramSTT } from "./stt/index.js";
 export { KokoroTTS } from "./tts/index.js";

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

@@ -0,0 +1,45 @@
+import type { LLM, LLMEvent, LLMRequest, LLMStreamTimingCallback, LLMUsageCallback } from "../../types.js";
+import type { FetchLike } from "../../../shared.js";
+export interface ClaudeOptions {
+    apiKey: string;
+    /** Defaults to `claude-sonnet-4-5`. */
+    model?: string;
+    /** Defaults to `https://api.anthropic.com/v1`. */
+    baseUrl?: string;
+    /** Injectable fetch implementation, mainly for tests. */
+    fetch?: FetchLike;
+    /** Provider-timeline hook: request-start / headers / first-chunk. */
+    onTiming?: LLMStreamTimingCallback;
+    /**
+     * Abort a stream that delivers no data for this long (default 8000ms) —
+     * protects against provider connections that go silent after the model
+     * already produced its output. Raise it for providers with slow TTFT.
+     */
+    idleTimeoutMs?: number;
+    /** Called with the provider-reported token usage (when included). */
+    onUsage?: LLMUsageCallback;
+}
+/**
+ * Claude LLM adapter (Anthropic Messages API over SSE).
+ *
+ * The wire format differs from the OpenAI-compatible adapters: tools are
+ * `input_schema` blocks, tool calls arrive as `tool_use` content blocks with
+ * `input_json_delta` fragments (reassembled here into `tool_call` events),
+ * tool results are `tool_result` blocks inside user messages, and `max_tokens`
+ * is required. There is no `response_format`, so `toolMode` is not supported —
+ * tool calling is always native.
+ */
+export declare class ClaudeLLM implements LLM {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly onTiming;
+    private readonly idleTimeoutMs;
+    private readonly onUsage;
+    private readonly streams;
+    constructor(options: ClaudeOptions);
+    /** Cancel every in-flight stream (parallel sub-generations included). */
+    stop(): void;
+    stream(request: LLMRequest): AsyncGenerator<LLMEvent>;
+}

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

@@ -0,0 +1,2 @@
+export { ClaudeLLM } from "./claude.js";
+export type { ClaudeOptions } from "./claude.js";

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

@@ -1,4 +1,4 @@
-import type { LLM, LLMEvent, LLMRequest } from "../../types.js";
+import type { LLM, LLMEvent, LLMRequest, LLMStreamTimingCallback, LLMUsageCallback, ToolMode } from "../../types.js";
 import type { FetchLike } from "../../../shared.js";
 export interface DeepSeekOptions {
     apiKey: string;
@@ -8,6 +8,22 @@ export interface DeepSeekOptions {
     baseUrl?: string;
     /** Injectable fetch implementation, mainly for tests. */
     fetch?: FetchLike;
+    /** Provider-timeline hook: request-start / headers / first-chunk. */
+    onTiming?: LLMStreamTimingCallback;
+    /**
+     * Abort a stream that delivers no data for this long (default 8000ms) —
+     * protects against provider connections that go silent after the model
+     * already produced its output. Raise it for providers with slow TTFT.
+     */
+    idleTimeoutMs?: number;
+    /** Called with the provider-reported token usage (when included). */
+    onUsage?: LLMUsageCallback;
+    /**
+     * Default tool encoding for requests that don't set `toolMode` (the
+     * request's `toolMode` wins). For models whose endpoints lack native tool
+     * calling.
+     */
+    toolMode?: ToolMode;
 }
 /**
  * DeepSeek LLM adapter (OpenAI-compatible chat completions over SSE).
@@ -17,8 +33,13 @@ export declare class DeepSeekLLM implements LLM {
     private readonly model;
     private readonly baseUrl;
     private readonly fetchImpl;
-    private abort;
+    private readonly onTiming;
+    private readonly idleTimeoutMs;
+    private readonly onUsage;
+    private readonly toolMode;
+    private readonly streams;
     constructor(options: DeepSeekOptions);
+    /** Cancel every in-flight stream (parallel sub-generations included). */
     stop(): void;
     stream(request: LLMRequest): AsyncGenerator<LLMEvent>;
 }

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

@@ -1 +1,4 @@
 export { DeepSeekLLM } from "./deepseek/deepseek.js";
+export { OpenRouterLLM } from "./openrouter/openrouter.js";
+export { OpenAILLM } from "./openai/openai.js";
+export { ClaudeLLM } from "./claude/claude.js";

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

@@ -0,0 +1,2 @@
+export { OpenAILLM } from "./openai.js";
+export type { OpenAIOptions } from "./openai.js";

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

@@ -0,0 +1,45 @@
+import type { LLM, LLMEvent, LLMRequest, LLMStreamTimingCallback, LLMUsageCallback, ToolMode } from "../../types.js";
+import type { FetchLike } from "../../../shared.js";
+export interface OpenAIOptions {
+    apiKey: string;
+    /** Defaults to `gpt-4o-mini`. */
+    model?: string;
+    /** Defaults to `https://api.openai.com/v1`. */
+    baseUrl?: string;
+    /** Injectable fetch implementation, mainly for tests. */
+    fetch?: FetchLike;
+    /** Provider-timeline hook: request-start / headers / first-chunk. */
+    onTiming?: LLMStreamTimingCallback;
+    /**
+     * Abort a stream that delivers no data for this long (default 8000ms) —
+     * protects against provider connections that go silent after the model
+     * already produced its output. Raise it for providers with slow TTFT.
+     */
+    idleTimeoutMs?: number;
+    /** Called with the provider-reported token usage (when included). */
+    onUsage?: LLMUsageCallback;
+    /**
+     * Default tool encoding for requests that don't set `toolMode` (the
+     * request's `toolMode` wins). For models whose endpoints lack native tool
+     * calling.
+     */
+    toolMode?: ToolMode;
+}
+/**
+ * OpenAI LLM adapter (OpenAI-compatible chat completions over SSE).
+ */
+export declare class OpenAILLM implements LLM {
+    private readonly apiKey;
+    private readonly model;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly onTiming;
+    private readonly idleTimeoutMs;
+    private readonly onUsage;
+    private readonly toolMode;
+    private readonly streams;
+    constructor(options: OpenAIOptions);
+    /** Cancel every in-flight stream (parallel sub-generations included). */
+    stop(): void;
+    stream(request: LLMRequest): AsyncGenerator<LLMEvent>;
+}