blazen 0.5.4 → 0.6.0

package/index.d.ts

@@ -10,7 +10,7 @@ export type JsActiveWorkflowSnapshot = ActiveWorkflowSnapshot
 /** The result of an agent run. */
 export declare class AgentResult {
   /** The final completion response from the model. */
-  get response(): JsCompletionResponse
+  get response(): JsModelResponse
   /** Full message history including all tool calls and results. */
   get messages(): Array<any>
   /** Number of tool-calling iterations that occurred. */
@@ -42,13 +42,13 @@ export declare class AnthropicProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsAnthropicProvider = AnthropicProvider
 
@@ -113,6 +113,53 @@ export declare class AssignmentContext {
 }
 export type JsAssignmentContext = AssignmentContext
 
+/**
+ * AudioGen text-to-SFX + text-to-music backend.
+ *
+ * Use the [`JsAudioGenBackend::create`] factory to construct an instance.
+ */
+export declare class AudioGenBackend {
+  /** Construct an AudioGen backend handle. */
+  static create(options?: JsAudioGenOptions | undefined | null): AudioGenBackend
+  /** Backend identifier, always `"audiogen-medium"`. */
+  get modelId(): string
+  /**
+   * Generate music conditioned on `prompt`.
+   *
+   * # Errors
+   * Returns `MusicInvalidInputError` for empty prompts or non-positive
+   * / out-of-range durations, `MusicHfHubError` on weight-download
+   * failure, `MusicCandleError` on inference failure, or
+   * `MusicEngineNotAvailableError` when the engine feature was
+   * compiled out.
+   */
+  generateMusic(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Generate sound-effect audio conditioned on `prompt`.
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`].
+   */
+  generateSfx(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Stream music generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`].
+   */
+  streamGenerateMusic(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+  /**
+   * Stream SFX generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`].
+   */
+  streamGenerateSfx(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+}
+export type JsAudioGenBackend = AudioGenBackend
+
 export declare class AudioMusicProviderDefaults {
   /** Construct role-specific defaults. */
   constructor(base?: BaseProviderDefaults | undefined | null, before?: BeforeRoleTsfn | undefined | null)
@@ -151,13 +198,13 @@ export declare class AzureOpenAiProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsAzureOpenAiProvider = AzureOpenAiProvider
 
@@ -193,118 +240,6 @@ export declare class BackgroundRemovalProviderDefaults {
 }
 export type JsBackgroundRemovalProviderDefaults = BackgroundRemovalProviderDefaults
 
-/**
- * A completion provider wrapper that applies a
- * [`JsCompletionProviderDefaults`] to every completion request before
- * delegating to the inner model.
- *
- * `BaseProvider` is intended to be subclassed from JavaScript:
- *
- * ```javascript
- * import { BaseProvider, CompletionModel } from "blazen";
- *
- * class TerseLlm extends BaseProvider {
- *   constructor() {
- *     const inner = CompletionModel.openai({ apiKey: "sk-..." });
- *     super(inner);
- *     this.withSystemPrompt("Be terse.");
- *   }
- * }
- * ```
- *
- * Today (V1) the constructor stores an opaque reference to the inner
- * object — Phase D will wire `class extends` to fire the JS `complete`
- * override before falling back to the inner Rust model.
- */
-export declare class BaseProvider {
-  /**
-   * Construct a new [`BaseProvider`].
-   *
-   * `inner` is the underlying completion model — pass a
-   * [`JsCompletionModel`] instance. JS subclasses that fully
-   * override `complete` may pass `null` here (Phase D will wire
-   * subclass dispatch end-to-end; today calls to `complete` on a
-   * subclass-only provider report unsupported).
-   *
-   * `defaults` optionally seeds the
-   * [`JsCompletionProviderDefaults`]; when omitted, an empty
-   * defaults bag is created.
-   */
-  constructor(inner?: JsCompletionModel | undefined | null, defaults?: JsCompletionProviderDefaults | undefined | null)
-  /**
-   * Set the default system prompt prepended to requests when no
-   * system message is already present.
-   */
-  withSystemPrompt(prompt: string): BaseProvider
-  /** Replace the default tools appended to every completion request. */
-  withTools(tools: Array<JsToolDefinition>): BaseProvider
-  /** Set the default `responseFormat` (JSON Schema object). */
-  withResponseFormat(format: any): BaseProvider
-  /**
-   * Set the universal `beforeRequest` hook (fires for any request
-   * type). V1: stored only — Phase B wires dispatch.
-   */
-  withBeforeRequest(hook: BeforeRequestTsfn): BaseProvider
-  /**
-   * Set the typed `beforeCompletion` hook (fires after the universal
-   * hook, with a typed completion request). V1: stored only — Phase
-   * B wires dispatch.
-   */
-  withBeforeCompletion(hook: BeforeCompletionTsfn): BaseProvider
-  /** Replace the entire defaults bag. */
-  withDefaults(defaults: JsCompletionProviderDefaults): BaseProvider
-  /** The currently-configured defaults. */
-  get defaults(): JsCompletionProviderDefaults
-  /**
-   * The inner model's `modelId`. Returns the empty string when the
-   * provider was constructed without a Rust-side `inner` (JS subclass
-   * path).
-   */
-  get modelId(): string
-  /**
-   * The provider identifier used for logging. Defaults to the inner
-   * model's `modelId` when present, otherwise `"base"`. Subclasses
-   * may override.
-   */
-  get providerId(): string
-  /**
-   * Typed structured extraction.
-   *
-   * Sends a completion request with a JSON Schema `response_format`
-   * envelope and parses the model's response as JSON. The schema
-   * argument is a plain JSON Schema object (callers using zod can
-   * convert with `zodToJsonSchema(zSchema)` from the `zod-to-json-schema`
-   * package).
-   *
-   * The `response_format` is wired up as the `OpenAI`-style
-   * `{"type":"json_schema","json_schema":{"name":"Extract","schema":...,"strict":true}}`
-   * envelope; provider implementations that don't natively support
-   * structured outputs fall back to a system-instruction shim (see
-   * `crates/blazen-llm/src/providers/anthropic.rs::build_json_schema_system_instruction`).
-   *
-   * Returns the parsed JSON value. The TypeScript surface declares
-   * the return as `any` because the schema shape is only known at
-   * runtime; callers can narrow via TS generics on their wrapper.
-   *
-   * ```typescript
-   * const schema = {
-   *   type: "object",
-   *   properties: {
-   *     name: { type: "string" },
-   *     age:  { type: "integer" },
-   *   },
-   *   required: ["name", "age"],
-   * };
-   * const result = await provider.extract(schema, [
-   *   ChatMessage.user("My name is Alice and I am 30."),
-   * ]);
-   * // -> { name: "Alice", age: 30 }
-   * ```
-   */
-  extract(schema: any, messages: Array<JsChatMessage>): Promise<any>
-}
-export type JsBaseProvider = BaseProvider
-
 /**
  * Universal provider defaults applicable to every provider role.
  *
@@ -372,7 +307,7 @@ export type JsBatchConfig = BatchConfig
  */
 export declare class BatchResult {
   /** One response per input request. `null` for failed requests. */
-  get responses(): Array<JsCompletionResponse | undefined | null>
+  get responses(): Array<JsModelResponse | undefined | null>
   /** One error message per input request. `null` for successful requests. */
   get errors(): Array<string | undefined | null>
   /** Aggregated token usage across all successful responses. */
@@ -408,13 +343,13 @@ export declare class BedrockProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsBedrockProvider = BedrockProvider
 
@@ -505,27 +440,27 @@ export type JsBytesWrapper = BytesWrapper
  * inner model.
  *
  * ```javascript
- * const cached = new CachedCompletionModel(
- *     CompletionModel.openai(),
+ * const cached = new CachedModel(
+ *     Model.openai(),
  *     { ttlSeconds: 300, maxEntries: 1000 },
  * );
  * ```
  */
-export declare class CachedCompletionModel {
+export declare class CachedModel {
   /** Wrap `model` with an in-memory response cache. */
-  constructor(model: CompletionModel, config?: JsCacheConfig | undefined | null)
+  constructor(model: Model, config?: JsCacheConfig | undefined | null)
   /** The wrapped model's id. */
   get modelId(): string
   /**
    * Perform a chat completion, returning a cached response on a
    * hit and otherwise delegating to the inner model.
    */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /**
    * Perform a chat completion with options. The full options object
    * is included in the cache key.
    */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /**
    * Stream a chat completion. Streaming requests bypass the cache
    * entirely.
@@ -535,19 +470,19 @@ export declare class CachedCompletionModel {
    * Stream a chat completion with options. Streaming requests bypass
    * the cache entirely.
    */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
   /**
-   * Convert this cache wrapper into a plain [`JsCompletionModel`] so
+   * Convert this cache wrapper into a plain [`JsModel`] so
    * it can be passed to APIs that expect the base type.
    */
-  toCompletionModel(): CompletionModel
+  toModel(): Model
 }
-export type JsCachedCompletionModel = CachedCompletionModel
+export type JsCachedModel = CachedModel
 
 /**
  * Built-in middleware that wraps the inner model with an in-memory
  * response cache. Equivalent to constructing a
- * [`super::wrappers::JsCachedCompletionModel`] but composable inside a
+ * [`super::wrappers::JsCachedModel`] but composable inside a
  * [`JsMiddlewareStack`].
  *
  * ```javascript
@@ -659,9 +594,9 @@ export declare class CandleLlmProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Explicitly load the model weights into memory / `VRAM`. */
@@ -879,7 +814,7 @@ export type JsCheckpointStore = CheckpointStore
 export declare class Citation {
   /**
    * Construct a citation. Most callers receive these via
-   * `CompletionResponse.citations` rather than building them by hand.
+   * `ModelResponse.citations` rather than building them by hand.
    */
   constructor(options: CitationOptions)
   /** The cited URL. */
@@ -899,6 +834,21 @@ export declare class Citation {
 }
 export type JsCitationClass = Citation
 
+/**
+ * Typed handle wrapping an `EnCodec` neural audio codec backend.
+ *
+ * Mirrors [`blazen_llm::CodecBackendHandle`]. Construct it directly to
+ * get a default `facebook/encodec_24khz` handle; weights load lazily on
+ * first encode/decode.
+ */
+export declare class CodecBackendHandle {
+  /** Build a default-configured `EnCodec` codec backend handle. */
+  constructor()
+  /** The wrapped backend's stable identifier. */
+  get id(): string
+}
+export type JsCodecBackendHandle = CodecBackendHandle
+
 /** A Cohere chat completion provider. */
 export declare class CohereProvider {
   /** Create a new Cohere provider. */
@@ -912,409 +862,94 @@ export declare class CohereProvider {
    */
   static embeddingModel(options?: JsProviderOptions | undefined | null): JsOpenAiCompatEmbeddingModel
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsCohereProvider = CohereProvider
 
 /**
- * A chat completion model.
- *
- * Use the static factory methods to create an instance for your provider:
- *
- * ```javascript
- * const model = CompletionModel.openai({ apiKey: "sk-..." });
- * const response = await model.complete([
- *   ChatMessage.user("What is 2 + 2?")
- * ]);
- * ```
- *
- * Or extend the class to implement a custom provider:
+ * Pluggable registry for multimodal content. Wraps
+ * [`Arc<dyn blazen_llm::content::ContentStore>`].
  *
- * ```javascript
- * class MyLLM extends CompletionModel {
- *   constructor() {
- *     super({ modelId: "my-custom-model" });
- *   }
- *   async complete(messages) { /* ... *\/ }
- * }
- * ```
+ * Construct via the static factories (e.g. `ContentStore.inMemory()`,
+ * `ContentStore.custom({ put, resolve, fetchBytes })`) or by extending
+ * `ContentStore` and overriding the async methods. Stores are cheap to
+ * clone — internally an `Arc` — so passing the same instance across
+ * multiple agents / requests is fine.
  */
-export declare class CompletionModel {
+export declare class ContentStore {
   /**
-   * Construct a base `CompletionModel`.
-   *
-   * Called by JavaScript subclasses via `super(config)`. The `config`
-   * parameter is optional and carries metadata such as `modelId`.
-   *
-   * Instances created this way have no inner Rust provider -- calling
-   * `complete()` or `stream()` without overriding them in the subclass
-   * will throw.
+   * Base-class constructor. Call from your subclass via `super()`.
+   * On its own, the base class is not useful — the default method
+   * implementations raise.
    */
-  constructor(config?: CompletionModelConfig | undefined | null)
-  /** Create an `OpenAI` completion model. */
-  static openai(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create an Anthropic completion model. */
-  static anthropic(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a Google Gemini completion model. */
-  static gemini(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create an Azure `OpenAI` completion model. */
-  static azure(options: JsAzureOptions): CompletionModel
+  constructor()
+  /** Build a default ephemeral in-memory store. */
+  static inMemory(): ContentStore
+  /** Build a store backed by the `OpenAI` Files API. */
+  static openaiFiles(apiKey: string, baseUrl?: string | undefined | null): ContentStore
+  /** Build a store backed by the Anthropic Files API. */
+  static anthropicFiles(apiKey: string, baseUrl?: string | undefined | null): ContentStore
+  /** Build a store backed by the Gemini Files API. */
+  static geminiFiles(apiKey: string, baseUrl?: string | undefined | null): ContentStore
+  /** Build a store backed by fal.ai's storage API. */
+  static falStorage(apiKey: string, baseUrl?: string | undefined | null): ContentStore
   /**
-   * Create a fal.ai completion model.
+   * Build a store backed by user-supplied async callbacks.
    *
-   * `options` optionally configures the LLM model, endpoint family,
-   * enterprise tier, and modality auto-routing. Defaults to the
-   * OpenAI-compatible chat-completions endpoint.
-   */
-  static fal(options?: JsFalOptions | undefined | null): CompletionModel
-  /** Create an `OpenRouter` completion model. */
-  static openrouter(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a Groq completion model. */
-  static groq(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a Together AI completion model. */
-  static together(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a Mistral AI completion model. */
-  static mistral(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a `DeepSeek` completion model. */
-  static deepseek(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a Fireworks AI completion model. */
-  static fireworks(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a Perplexity completion model. */
-  static perplexity(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create an xAI (Grok) completion model. */
-  static xai(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create a Cohere completion model. */
-  static cohere(options?: JsProviderOptions | undefined | null): CompletionModel
-  /** Create an AWS Bedrock completion model. */
-  static bedrock(options: JsBedrockOptions): CompletionModel
-  /**
-   * Create a local Ollama completion model.
+   * Mirrors the Rust [`CustomContentStore::builder`] API. The
+   * `options` object must provide at least `put`, `resolve`, and
+   * `fetchBytes`; `fetchStream` and `delete` are optional. All
+   * callbacks must be `async` (or return a `Promise`).
    *
-   * Talks to a running Ollama server (defaults to `http://host:port/v1`).
-   * No API key is required.
+   * Argument shapes seen by JS:
    *
-   * ```javascript
-   * const model = CompletionModel.ollama("localhost", 11434, "llama3.1:8b");
-   * ```
+   * - `put(body, hint)`: `body` is a JSON-tagged
+   *   [`ContentBody`] (`{type: "bytes", data: number[]}`,
+   *   `{type: "url", url: string}`, `{type: "local_path", path: string}`,
+   *   or `{type: "provider_file", provider: string, id: string}`).
+   *   `hint` is a [`ContentHint`] dict (all fields optional). Must
+   *   resolve with a [`ContentHandle`]-shaped object
+   *   `{id, kind, mimeType?, byteSize?, displayName?}`.
+   * - `resolve(handle)`: `handle` is a [`ContentHandle`] dict. Must
+   *   resolve with a serialized [`MediaSource`] object
+   *   (e.g. `{type: "url", url: "..."}`).
+   * - `fetchBytes(handle)`: must resolve with a `Buffer`,
+   *   `Uint8Array`, or `number[]` of bytes.
+   * - `fetchStream(handle)` (optional): may resolve with either bytes
+   *   (`Buffer` / `Uint8Array` / `number[]` / base64 string) or an
+   *   `AsyncIterable<Uint8Array>` for chunk-by-chunk streaming.
+   * - `delete(handle)` (optional): must resolve with `undefined`.
    */
-  static ollama(host: string, port: number, model: string): CompletionModel
+  static custom(options: CustomContentStoreOptions): ContentStore
   /**
-   * Create a local LM Studio completion model.
-   *
-   * Talks to a running LM Studio server's OpenAI-compatible endpoint.
+   * Persist content and return a freshly-issued handle.
    *
-   * ```javascript
-   * const model = CompletionModel.lmStudio("localhost", 1234, "my-model");
-   * ```
+   * `body` is either:
+   * - a `Buffer` — inline bytes uploaded to the store, or
+   * - a `string` — interpreted as a URL when it contains `"://"` (the
+   *   store records the reference) and as a local filesystem path
+   *   otherwise (the store reads or copies the file as needed).
    */
-  static lmStudio(host: string, port: number, model: string): CompletionModel
+  put(body: Buffer | string, options: PutOptions): Promise<JsContentHandle>
   /**
-   * Create a generic OpenAI-compatible completion model.
-   *
-   * Drives any OpenAI-compatible chat-completions endpoint with the
-   * supplied [`JsOpenAiCompatConfig`].
-   *
-   * ```javascript
-   * const model = CompletionModel.openaiCompat("my-host", {
-   *   providerName: "my-host",
-   *   baseUrl: "https://api.example.com/v1",
-   *   apiKey: "sk-...",
-   *   defaultModel: "my-model",
-   * });
-   * ```
+   * Resolve a handle to a wire-renderable [`MediaSource`] (returned as a
+   * JS object — the same JSON shape Blazen's request builders accept).
    */
-  static openaiCompat(providerId: string, config: JsOpenAiCompatConfig): CompletionModel
+  resolve(handle: JsContentHandle): Promise<any>
   /**
-   * Create a fully user-defined completion model backed by a JavaScript
-   * host object.
-   *
-   * `hostObject` must expose Blazen capability methods (e.g.
-   * `complete`, `stream`) using the camelCase trait-method names. The
-   * optional `providerId` is used for logging; defaults to `"custom"`.
-   *
-   * ```javascript
-   * class MyProvider {
-   *   async complete(request) { /* ... *\/ }
-   * }
-   * const model = CompletionModel.custom(new MyProvider(), "my-provider");
-   * ```
-   */
-  static custom(hostObject: object, providerId?: string | undefined | null): CompletionModel
-  /** Get the model ID. */
-  get modelId(): string
-  /**
-   * Wrap this model with automatic retry on transient failures.
-   *
-   * ```javascript
-   * const model = CompletionModel.openrouter({ apiKey: key });
-   * const withRetry = model.withRetry({ maxRetries: 3, initialDelayMs: 1000 });
-   * ```
-   */
-  withRetry(config?: JsRetryConfig | undefined | null): CompletionModel
-  /**
-   * Wrap this model with an in-memory response cache.
-   *
-   * Streaming requests are never cached and always delegate directly to the
-   * underlying model.
-   *
-   * ```javascript
-   * const cached = model.withCache({ ttlSeconds: 300, maxEntries: 1000 });
-   * ```
-   */
-  withCache(config?: JsCacheConfig | undefined | null): CompletionModel
-  /**
-   * Create a fallback model that tries multiple providers in order.
-   *
-   * When the primary provider fails with a transient error (rate limit,
-   * timeout, server error) the request is automatically forwarded to the
-   * next provider. Non-retryable errors short-circuit immediately.
-   *
-   * ```javascript
-   * const model = CompletionModel.withFallback([modelA, modelB]);
-   * ```
-   */
-  static withFallback(models: Array<CompletionModel>): CompletionModel
-  /**
-   * Perform a chat completion.
-   *
-   * Messages should be an array of `ChatMessage` instances.
-   *
-   * Returns a typed response with `content`, `toolCalls`, `usage`, `model`,
-   * and `finishReason` fields.
-   */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
-  /**
-   * Perform a chat completion with additional options.
-   *
-   * Options object may include:
-   * - `temperature` (number): Sampling temperature (0.0 - 2.0)
-   * - `maxTokens` (number): Maximum tokens to generate
-   * - `topP` (number): Nucleus sampling parameter
-   * - `model` (string): Override the default model
-   * - `tools` (array): Tool definitions for function calling
-   */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
-  /**
-   * Stream a chat completion.
-   *
-   * The `onChunk` callback receives each chunk as a typed `StreamChunk` with
-   * `delta`, `finishReason`, and `toolCalls` fields.
-   *
-   * ```javascript
-   * await model.stream(
-   *   [ChatMessage.user("Tell me a story")],
-   *   (chunk) => { if (chunk.delta) process.stdout.write(chunk.delta); }
-   * );
-   * ```
-   */
-  stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
-  /**
-   * Stream a chat completion with additional options.
-   *
-   * Options object may include:
-   * - `temperature` (number): Sampling temperature (0.0 - 2.0)
-   * - `maxTokens` (number): Maximum tokens to generate
-   * - `topP` (number): Nucleus sampling parameter
-   * - `model` (string): Override the default model
-   * - `tools` (array): Tool definitions for function calling
-   */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
-  /**
-   * Explicitly load the model weights into memory / `VRAM`.
-   *
-   * For remote providers (`OpenAI`, Anthropic, fal, etc.) this throws --
-   * there is no local model to load. For local providers (mistral.rs,
-   * llama.cpp, candle) this triggers the download + load synchronously,
-   * so the next inference call does not pay the startup cost.
-   *
-   * Idempotent: calling `load` on an already-loaded model is a no-op
-   * that resolves immediately.
-   */
-  load(): Promise<void>
-  /**
-   * Drop the loaded model and free its memory / `VRAM`.
-   *
-   * For remote providers this throws. For local providers this frees
-   * `GPU` memory so the process can load a different model. Idempotent.
-   */
-  unload(): Promise<void>
-  /**
-   * Whether the model is currently loaded in memory / `VRAM`.
-   *
-   * Always returns `false` for remote providers (they have no local
-   * model to load). Returns the real state for local providers.
-   */
-  isLoaded(): Promise<boolean>
-  /**
-   * Approximate memory footprint in bytes (host RAM if the
-   * provider targets the CPU, GPU VRAM otherwise), if the
-   * implementation can report it. Returns `null` for remote
-   * providers or for local providers that do not expose memory
-   * usage.
-   *
-   * Note: napi-rs exposes this as a JS `number`. The underlying
-   * [`blazen_llm::LocalModel::memory_bytes`] returns `u64`; we clamp
-   * to `i64::MAX` (~9.2 exabytes) when surfacing through
-   * `JSON`-compatible types, which is effectively lossless for any
-   * realistic footprint.
-   */
-  memoryBytes(): Promise<number | null>
-  /**
-   * Create a local mistral.rs completion model.
-   *
-   * Runs LLM inference entirely on-device -- no API key required.
-   *
-   * ```javascript
-   * const model = CompletionModel.mistralrs({
-   *   modelId: "mistralai/Mistral-7B-Instruct-v0.3",
-   * });
-   * ```
-   */
-  static mistralrs(options: JsMistralRsOptions): CompletionModel
-  /**
-   * Wrap this model in a [`TracingCompletionModel`] that emits a
-   * structured `tracing` span around every `complete` and `stream`
-   * call.
-   *
-   * `name` is recorded on the span as the `provider` field. It is
-   * leaked into a `&'static str` because the underlying span macro
-   * captures it by reference for the process lifetime; this is
-   * intentional and bounded by the small set of distinct provider
-   * names a typical application uses.
-   *
-   * ```javascript
-   * const traced = CompletionModel.openai({ apiKey }).withTracing("openai");
-   * ```
-   */
-  withTracing(name: string): CompletionModel
-}
-export type JsCompletionModel = CompletionModel
-
-/**
- * Completion-role provider defaults: system prompt, default tools,
- * `responseFormat`, and a typed `beforeCompletion` hook.
- *
- * ```javascript
- * import { BaseProviderDefaults, CompletionProviderDefaults } from "blazen";
- *
- * const d = new CompletionProviderDefaults(
- *   new BaseProviderDefaults(),
- *   "Be terse.",
- *   [], // default tools
- *   { type: "json_object" },
- *   async (request) => { /* mutate request *\/ },
- * );
- * ```
- */
-export declare class CompletionProviderDefaults {
-  /** Construct completion-role defaults. */
-  constructor(base?: BaseProviderDefaults | undefined | null, systemPrompt?: string | undefined | null, tools?: Array<JsToolDefinition> | undefined | null, responseFormat?: any | undefined | null, beforeCompletion?: BeforeCompletionTsfn | undefined | null)
-  /**
-   * The system prompt prepended to requests when the request itself
-   * carries no system message.
-   */
-  get systemPrompt(): string | null
-  /** Replace the system prompt. Pass `null` to clear. */
-  set systemPrompt(value: string | undefined | null)
-  /** The default tools appended to every completion request. */
-  get tools(): Array<JsToolDefinition>
-  /** Replace the default tools. */
-  set tools(value: Array<JsToolDefinition> | undefined | null)
-  /** Default `response_format` (JSON Schema or similar object). */
-  get responseFormat(): any | null
-  /** Replace the default `responseFormat`. Pass `null` to clear. */
-  set responseFormat(value: any | undefined | null)
-  /** Returns `true` when a `beforeCompletion` hook is configured. */
-  get hasBeforeCompletion(): boolean
-  /** Replace the typed `beforeCompletion` hook. Pass `null` to clear. */
-  set beforeCompletion(hook: BeforeCompletionTsfn | undefined | null)
-}
-export type JsCompletionProviderDefaults = CompletionProviderDefaults
-
-/**
- * Pluggable registry for multimodal content. Wraps
- * [`Arc<dyn blazen_llm::content::ContentStore>`].
- *
- * Construct via the static factories (e.g. `ContentStore.inMemory()`,
- * `ContentStore.custom({ put, resolve, fetchBytes })`) or by extending
- * `ContentStore` and overriding the async methods. Stores are cheap to
- * clone — internally an `Arc` — so passing the same instance across
- * multiple agents / requests is fine.
- */
-export declare class ContentStore {
-  /**
-   * Base-class constructor. Call from your subclass via `super()`.
-   * On its own, the base class is not useful — the default method
-   * implementations raise.
-   */
-  constructor()
-  /** Build a default ephemeral in-memory store. */
-  static inMemory(): ContentStore
-  /** Build a store backed by the `OpenAI` Files API. */
-  static openaiFiles(apiKey: string, baseUrl?: string | undefined | null): ContentStore
-  /** Build a store backed by the Anthropic Files API. */
-  static anthropicFiles(apiKey: string, baseUrl?: string | undefined | null): ContentStore
-  /** Build a store backed by the Gemini Files API. */
-  static geminiFiles(apiKey: string, baseUrl?: string | undefined | null): ContentStore
-  /** Build a store backed by fal.ai's storage API. */
-  static falStorage(apiKey: string, baseUrl?: string | undefined | null): ContentStore
-  /**
-   * Build a store backed by user-supplied async callbacks.
-   *
-   * Mirrors the Rust [`CustomContentStore::builder`] API. The
-   * `options` object must provide at least `put`, `resolve`, and
-   * `fetchBytes`; `fetchStream` and `delete` are optional. All
-   * callbacks must be `async` (or return a `Promise`).
-   *
-   * Argument shapes seen by JS:
-   *
-   * - `put(body, hint)`: `body` is a JSON-tagged
-   *   [`ContentBody`] (`{type: "bytes", data: number[]}`,
-   *   `{type: "url", url: string}`, `{type: "local_path", path: string}`,
-   *   or `{type: "provider_file", provider: string, id: string}`).
-   *   `hint` is a [`ContentHint`] dict (all fields optional). Must
-   *   resolve with a [`ContentHandle`]-shaped object
-   *   `{id, kind, mimeType?, byteSize?, displayName?}`.
-   * - `resolve(handle)`: `handle` is a [`ContentHandle`] dict. Must
-   *   resolve with a serialized [`MediaSource`] object
-   *   (e.g. `{type: "url", url: "..."}`).
-   * - `fetchBytes(handle)`: must resolve with a `Buffer`,
-   *   `Uint8Array`, or `number[]` of bytes.
-   * - `fetchStream(handle)` (optional): may resolve with either bytes
-   *   (`Buffer` / `Uint8Array` / `number[]` / base64 string) or an
-   *   `AsyncIterable<Uint8Array>` for chunk-by-chunk streaming.
-   * - `delete(handle)` (optional): must resolve with `undefined`.
-   */
-  static custom(options: CustomContentStoreOptions): ContentStore
-  /**
-   * Persist content and return a freshly-issued handle.
-   *
-   * `body` is either:
-   * - a `Buffer` — inline bytes uploaded to the store, or
-   * - a `string` — interpreted as a URL when it contains `"://"` (the
-   *   store records the reference) and as a local filesystem path
-   *   otherwise (the store reads or copies the file as needed).
-   */
-  put(body: Buffer | string, options: PutOptions): Promise<JsContentHandle>
-  /**
-   * Resolve a handle to a wire-renderable [`MediaSource`] (returned as a
-   * JS object — the same JSON shape Blazen's request builders accept).
-   */
-  resolve(handle: JsContentHandle): Promise<any>
-  /**
-   * Fetch raw bytes for a handle. Tools that need to operate on the
-   * actual content (parse a PDF, transcribe audio) call this; most tools
-   * reason over the handle and let `resolve` produce the wire form.
-   */
-  fetchBytes(handle: JsContentHandle): Promise<Buffer>
-  /**
-   * Stream raw bytes for a handle chunk-by-chunk.
+   * Fetch raw bytes for a handle. Tools that need to operate on the
+   * actual content (parse a PDF, transcribe audio) call this; most tools
+   * reason over the handle and let `resolve` produce the wire form.
+   */
+  fetchBytes(handle: JsContentHandle): Promise<Buffer>
+  /**
+   * Stream raw bytes for a handle chunk-by-chunk.
    *
    * Returns a `Promise<AsyncIterable<Uint8Array>>`. Each `next()` call on
    * the iterator pulls one chunk from the underlying [`ByteStream`]; the
@@ -1373,7 +1008,7 @@ export declare class Context {
    * The event will be routed to any step whose `eventTypes` list includes
    * its event type. The event object must have a `type` field.
    */
-  sendEvent(event: any): Promise<void>
+  sendEvent(event: Event): Promise<void>
   /**
    * Publish an event to the external broadcast stream.
    *
@@ -1381,7 +1016,7 @@ export declare class Context {
    * Unlike `sendEvent`, this does NOT route the event through the
    * internal step registry.
    */
-  writeEventToStream(event: any): Promise<void>
+  writeEventToStream(event: Event): Promise<void>
   /**
    * Store raw binary data under the given key.
    *
@@ -1784,13 +1419,13 @@ export declare class DeepSeekProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsDeepSeekProvider = DeepSeekProvider
 
@@ -1925,9 +1560,35 @@ export declare class EmbeddingModel {
 export type JsEmbeddingModel = EmbeddingModel
 
 /**
- * Embedding-role provider defaults. V1 just wraps a
- * [`JsBaseProviderDefaults`].
- */
+ * r" Base class for vector-embedding providers.
+ * r"
+ * r" Mirrors the [`blazen_llm::providers::EmbeddingProvider`] capability
+ * r" trait. Subclass and override `embed()` to implement a custom embedding
+ * r" backend.
+ */
+export declare class EmbeddingProvider {
+  constructor(config: CapabilityProviderConfig)
+  /** The provider identifier. */
+  get providerId(): string | null
+  /** The base URL, if set. */
+  get baseUrl(): string | null
+  /**
+   * Estimated memory footprint in bytes (host RAM if the
+   * provider targets the CPU, GPU VRAM otherwise), if set.
+   */
+  get memoryEstimateBytes(): number | null
+  /**
+   * r" Embed a batch of texts. Receives an array of strings and returns
+   * r" an array of float vectors (one per input).
+   */
+  embed(texts: any): Promise<any>
+}
+export type JsEmbeddingProvider = EmbeddingProvider
+
+/**
+ * Embedding-role provider defaults. V1 just wraps a
+ * [`JsBaseProviderDefaults`].
+ */
 export declare class EmbeddingProviderDefaults {
   /** Construct embedding-role defaults. */
   constructor(base?: BaseProviderDefaults | undefined | null)
@@ -2046,26 +1707,26 @@ export declare class FallbackModel {
    * degenerate -- prefer using the underlying model directly in that
    * case.
    */
-  constructor(models: Array<CompletionModel>)
+  constructor(models: Array<Model>)
   /** The model id of the primary provider. */
   get modelId(): string
   /** Perform a chat completion, falling back across providers. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with options, falling back across providers. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /**
    * Stream a chat completion, falling back across providers on
    * retryable initial-stream failures.
    */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
   /**
-   * Convert this fallback wrapper into a plain [`JsCompletionModel`]
+   * Convert this fallback wrapper into a plain [`JsModel`]
    * so it can be passed to APIs that expect the base type
    * (`Agent`, `Batch`, further wrappers, etc.).
    */
-  toCompletionModel(): CompletionModel
+  toModel(): Model
 }
 export type JsFallbackModel = FallbackModel
 
@@ -2141,7 +1802,7 @@ export declare class FalProvider {
   /** Alias for [`awaitCompletion`](Self::await_completion). */
   result(handle: JsJobHandle): Promise<JsComputeResult>
   /** Perform a chat completion via fal.ai's `any-llm` proxy. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
 }
 export type JsFalProvider = FalProvider
 
@@ -2183,6 +1844,26 @@ export declare class FastEmbedModel {
 }
 export type JsFastEmbedModel = FastEmbedModel
 
+/**
+ * The faster-whisper STT backend.
+ *
+ * Mirrors [`blazen_llm::FasterWhisperBackend`]. Construct with an
+ * optional [`FasterWhisperConfig`](JsFasterWhisperConfig); weights load
+ * lazily on first transcription.
+ */
+export declare class FasterWhisperBackend {
+  /**
+   * Build a faster-whisper backend. No weights are loaded until the
+   * first transcription call.
+   */
+  constructor(config?: FasterWhisperConfig | undefined | null)
+  /** The stable backend identifier (`faster-whisper:<model_id>`). */
+  get id(): string
+  /** Wrap this backend in a typed [`SttBackendHandle`]. */
+  intoHandle(): JsSttBackendHandle
+}
+export type JsFasterWhisperBackend = FasterWhisperBackend
+
 /** A Fireworks AI chat completion provider. */
 export declare class FireworksProvider {
   /** Create a new Fireworks provider. */
@@ -2196,13 +1877,13 @@ export declare class FireworksProvider {
    */
   static embeddingModel(options?: JsProviderOptions | undefined | null): OpenAiCompatEmbeddingModel
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsFireworksProvider = FireworksProvider
 
@@ -2220,13 +1901,13 @@ export declare class GeminiProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsGeminiProvider = GeminiProvider
 
@@ -2237,13 +1918,13 @@ export declare class GroqProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsGroqProvider = GroqProvider
 
@@ -2412,6 +2093,31 @@ export declare class ImageGenerationProviderDefaults {
 }
 export type JsImageGenerationProviderDefaults = ImageGenerationProviderDefaults
 
+/**
+ * r" Base class for 2D image-generation providers.
+ * r"
+ * r" Mirrors the [`blazen_llm::providers::ImageGenProvider`] capability
+ * r" trait. Subclass and override `generateImage()` (and optionally
+ * r" `upscaleImage()`) to implement a custom image backend.
+ */
+export declare class ImageGenProvider {
+  constructor(config: CapabilityProviderConfig)
+  /** The provider identifier. */
+  get providerId(): string | null
+  /** The base URL, if set. */
+  get baseUrl(): string | null
+  /**
+   * Estimated memory footprint in bytes (host RAM if the
+   * provider targets the CPU, GPU VRAM otherwise), if set.
+   */
+  get memoryEstimateBytes(): number | null
+  /** r" Generate images from a text prompt. */
+  generateImage(request: any): Promise<any>
+  /** r" Upscale an existing image. */
+  upscaleImage(request: any): Promise<any>
+}
+export type JsImageGenProvider = ImageGenProvider
+
 /**
  * Base class for custom image-generation providers.
  *
@@ -2689,6 +2395,26 @@ export declare class JsonlBackend {
 }
 export type JsJsonlBackend = JsonlBackend
 
+/**
+ * JSONL-backed training dataset.
+ *
+ * Each line of the input file must deserialize to either
+ * `{"messages": [{"role": ..., "content": ...}, ...]}` (OpenAI shape)
+ * or `{"prompt": "...", "completion": "..."}` (legacy SFT).
+ */
+export declare class JsonlDataset {
+  /**
+   * Load a JSONL training file using the tokenizer at `tokenizerPath`.
+   *
+   * # Errors
+   *
+   * Throws if the tokenizer cannot be loaded, the device string is
+   * invalid, or the JSONL file fails to parse.
+   */
+  static fromPath(path: string, tokenizerPath: string, opts?: JsJsonlDatasetOptions | undefined | null): JsonlDataset
+}
+export type JsJsonlDataset = JsonlDataset
+
 /**
  * Configuration for the Langfuse exporter.
  *
@@ -2831,9 +2557,9 @@ export declare class LlamaCppProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Explicitly load the model weights into memory / `VRAM`. */
@@ -2850,6 +2576,149 @@ export declare class LlamaCppProvider {
 }
 export type JsLlamaCppProvider = LlamaCppProvider
 
+/**
+ * r" Base class for large-language-model providers.
+ * r"
+ * r" Mirrors the [`blazen_llm::providers::LLMProvider`] capability trait.
+ * r" Subclass and override `complete()` (and optionally `stream()`) to
+ * r" implement a custom chat/completion backend.
+ */
+export declare class LLMProvider {
+  constructor(config: CapabilityProviderConfig)
+  /** The provider identifier. */
+  get providerId(): string | null
+  /** The base URL, if set. */
+  get baseUrl(): string | null
+  /**
+   * Estimated memory footprint in bytes (host RAM if the
+   * provider targets the CPU, GPU VRAM otherwise), if set.
+   */
+  get memoryEstimateBytes(): number | null
+  /**
+   * r" Non-streaming completion. Receives a `ModelRequest`-shaped object
+   * r" and returns a `ModelResponse`-shaped object.
+   */
+  complete(request: any): Promise<any>
+  /**
+   * r" Streaming completion. Receives a `ModelRequest`-shaped object and
+   * r" returns the accumulated stream chunks.
+   */
+  stream(request: any): Promise<any>
+}
+export type JsLLMProvider = LLMProvider
+
+/**
+ * A completion provider wrapper that applies a
+ * [`JsProviderDefaults`] to every completion request before
+ * delegating to the inner model.
+ *
+ * `LlmProviderDefaults` is intended to be subclassed from JavaScript:
+ *
+ * ```javascript
+ * import { LlmProviderDefaults, Model } from "blazen";
+ *
+ * class TerseLlm extends LlmProviderDefaults {
+ *   constructor() {
+ *     const inner = Model.openai({ apiKey: "sk-..." });
+ *     super(inner);
+ *     this.withSystemPrompt("Be terse.");
+ *   }
+ * }
+ * ```
+ *
+ * Today (V1) the constructor stores an opaque reference to the inner
+ * object — Phase D will wire `class extends` to fire the JS `complete`
+ * override before falling back to the inner Rust model.
+ */
+export declare class LlmProviderDefaults {
+  /**
+   * Construct a new [`LlmProviderDefaults`].
+   *
+   * `inner` is the underlying completion model — pass a
+   * [`JsModel`] instance. JS subclasses that fully
+   * override `complete` may pass `null` here (Phase D will wire
+   * subclass dispatch end-to-end; today calls to `complete` on a
+   * subclass-only provider report unsupported).
+   *
+   * `defaults` optionally seeds the
+   * [`JsProviderDefaults`]; when omitted, an empty
+   * defaults bag is created.
+   */
+  constructor(inner?: JsModel | undefined | null, defaults?: JsProviderDefaults | undefined | null)
+  /**
+   * Set the default system prompt prepended to requests when no
+   * system message is already present.
+   */
+  withSystemPrompt(prompt: string): LlmProviderDefaults
+  /** Replace the default tools appended to every completion request. */
+  withTools(tools: Array<JsToolDefinition>): LlmProviderDefaults
+  /** Set the default `responseFormat` (JSON Schema object). */
+  withResponseFormat(format: any): LlmProviderDefaults
+  /**
+   * Set the universal `beforeRequest` hook (fires for any request
+   * type). V1: stored only — Phase B wires dispatch.
+   */
+  withBeforeRequest(hook: BeforeRequestTsfn): LlmProviderDefaults
+  /**
+   * Set the typed `beforeModel` hook (fires after the universal
+   * hook, with a typed completion request). V1: stored only — Phase
+   * B wires dispatch.
+   */
+  withBeforeModel(hook: BeforeModelTsfn): LlmProviderDefaults
+  /** Replace the entire defaults bag. */
+  withDefaults(defaults: JsProviderDefaults): LlmProviderDefaults
+  /** The currently-configured defaults. */
+  get defaults(): JsProviderDefaults
+  /**
+   * The inner model's `modelId`. Returns the empty string when the
+   * provider was constructed without a Rust-side `inner` (JS subclass
+   * path).
+   */
+  get modelId(): string
+  /**
+   * The provider identifier used for logging. Defaults to the inner
+   * model's `modelId` when present, otherwise `"base"`. Subclasses
+   * may override.
+   */
+  get providerId(): string
+  /**
+   * Typed structured extraction.
+   *
+   * Sends a completion request with a JSON Schema `response_format`
+   * envelope and parses the model's response as JSON. The schema
+   * argument is a plain JSON Schema object (callers using zod can
+   * convert with `zodToJsonSchema(zSchema)` from the `zod-to-json-schema`
+   * package).
+   *
+   * The `response_format` is wired up as the `OpenAI`-style
+   * `{"type":"json_schema","json_schema":{"name":"Extract","schema":...,"strict":true}}`
+   * envelope; provider implementations that don't natively support
+   * structured outputs fall back to a system-instruction shim (see
+   * `crates/blazen-llm/src/providers/anthropic.rs::build_json_schema_system_instruction`).
+   *
+   * Returns the parsed JSON value. The TypeScript surface declares
+   * the return as `any` because the schema shape is only known at
+   * runtime; callers can narrow via TS generics on their wrapper.
+   *
+   * ```typescript
+   * const schema = {
+   *   type: "object",
+   *   properties: {
+   *     name: { type: "string" },
+   *     age:  { type: "integer" },
+   *   },
+   *   required: ["name", "age"],
+   * };
+   * const result = await provider.extract(schema, [
+   *   ChatMessage.user("My name is Alice and I am 30."),
+   * ]);
+   * // -> { name: "Alice", age: 30 }
+   * ```
+   */
+  extract(schema: any, messages: Array<JsChatMessage>): Promise<any>
+}
+export type JsBaseProvider = LlmProviderDefaults
+
 /**
  * Base class for in-process model providers that load weights into
  * memory / VRAM.
@@ -2892,6 +2761,51 @@ export declare class LocalModel {
 }
 export type JsLocalModel = LocalModel
 
+/**
+ * A pipeline stage that re-runs an inner stage until a hard iteration cap is
+ * reached.
+ *
+ * The inner stage is a [`JsStage`] (sequential) or [`JsParallelStage`]
+ * (parallel); it is consumed at construction time, so the same `Stage` /
+ * `ParallelStage` instance cannot be reused. As noted in the module docs,
+ * the v1 loop runs the inner stage exactly `maxIterations` times.
+ *
+ * ```typescript
+ * const inner = new Stage("refine", wf);
+ * const loop = new LoopStage("refine-loop", 3, inner);
+ * ```
+ */
+export declare class LoopStage {
+  /**
+   * Create a loop stage from a sequential [`JsStage`].
+   *
+   * `maxIterations` is the hard cap on the number of rounds. The inner
+   * stage is consumed at construction time.
+   */
+  constructor(name: string, maxIterations: number, inner: JsStage)
+  /**
+   * Create a loop stage whose inner body is a parallel fan-out stage.
+   *
+   * `maxIterations` is the hard cap on the number of rounds. The inner
+   * parallel stage is consumed at construction time.
+   */
+  static fromParallel(name: string, maxIterations: number, inner: JsParallelStage): LoopStage
+  /**
+   * The loop stage's human-readable name.
+   *
+   * Returns an empty string if the stage has already been consumed by a
+   * `Pipeline`.
+   */
+  get name(): string
+  /**
+   * The hard iteration cap.
+   *
+   * Returns `0` if the stage has already been consumed by a `Pipeline`.
+   */
+  get maxIterations(): number
+}
+export type JsLoopStage = LoopStage
+
 /**
  * A memory store that uses ELID for vector indexing and similarity search.
  *
@@ -3139,7 +3053,7 @@ export type JsMiddleware = Middleware
  * const stack = new MiddlewareStack();
  * stack.withRetry({ maxRetries: 3 });
  * stack.withCache({ ttlSeconds: 300 });
- * const wrapped = stack.apply(CompletionModel.openai());
+ * const wrapped = stack.apply(Model.openai());
  * ```
  */
 export declare class MiddlewareStack {
@@ -3171,12 +3085,12 @@ export declare class MiddlewareStack {
   get length(): number
   /**
    * Apply every registered layer to `model` and return the wrapped
-   * model as a fresh [`JsCompletionModel`].
+   * model as a fresh [`JsModel`].
    *
    * The stack itself is left intact and can be re-applied to other
    * models.
    */
-  apply(model: CompletionModel): CompletionModel
+  apply(model: JsModel): JsModel
 }
 export type JsMiddlewareStack = MiddlewareStack
 
@@ -3187,13 +3101,13 @@ export declare class MistralProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsMistralProvider = MistralProvider
 
@@ -3216,9 +3130,9 @@ export declare class MistralRsProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Explicitly load the model weights into memory / `VRAM`. */
@@ -3236,61 +3150,554 @@ export declare class MistralRsProvider {
 export type JsMistralRsProvider = MistralRsProvider
 
 /**
- * Local cache for ML models downloaded from `HuggingFace` Hub.
+ * A chat completion model.
  *
- * Models are stored under `{cacheDir}/{repoId}/{filename}`. Files are
- * downloaded only once; subsequent calls return the cached path immediately.
+ * Use the static factory methods to create an instance for your provider:
  *
  * ```javascript
- * import { ModelCache } from 'blazen';
+ * const model = Model.openai({ apiKey: "sk-..." });
+ * const response = await model.complete([
+ *   ChatMessage.user("What is 2 + 2?")
+ * ]);
+ * ```
  *
- * const cache = ModelCache.create();
- * if (!cache.isCached('bert-base-uncased', 'config.json')) {
- *   await cache.download('bert-base-uncased', 'config.json', (downloaded, total) => {
- *     if (total !== null) {
- *       console.log(`${(downloaded / total * 100).toFixed(1)}%`);
- *     }
- *   });
+ * Or extend the class to implement a custom provider:
+ *
+ * ```javascript
+ * class MyLLM extends Model {
+ *   constructor() {
+ *     super({ modelId: "my-custom-model" });
+ *   }
+ *   async complete(messages) { /* ... *\/ }
  * }
  * ```
  */
-export declare class ModelCache {
+export declare class Model {
   /**
-   * Create a cache in the default location.
+   * Construct a base `Model`.
    *
-   * Uses `$BLAZEN_CACHE_DIR/models/` if set, otherwise falls back to
-   * `~/.cache/blazen/models/`.
+   * Called by JavaScript subclasses via `super(config)`. The `config`
+   * parameter is optional and carries metadata such as `modelId`.
+   *
+   * Instances created this way have no inner Rust provider -- calling
+   * `complete()` or `stream()` without overriding them in the subclass
+   * will throw.
    */
-  static create(): ModelCache
+  constructor(config?: ModelConfig | undefined | null)
+  /** Create an `OpenAI` completion model. */
+  static openai(options?: JsProviderOptions | undefined | null): Model
+  /** Create an Anthropic completion model. */
+  static anthropic(options?: JsProviderOptions | undefined | null): Model
+  /** Create a Google Gemini completion model. */
+  static gemini(options?: JsProviderOptions | undefined | null): Model
+  /** Create an Azure `OpenAI` completion model. */
+  static azure(options: JsAzureOptions): Model
   /**
-   * Create a cache rooted at a specific directory.
+   * Create a fal.ai completion model.
+   *
+   * `options` optionally configures the LLM model, endpoint family,
+   * enterprise tier, and modality auto-routing. Defaults to the
+   * OpenAI-compatible chat-completions endpoint.
+   */
+  static fal(options?: JsFalOptions | undefined | null): Model
+  /** Create an `OpenRouter` completion model. */
+  static openrouter(options?: JsProviderOptions | undefined | null): Model
+  /** Create a Groq completion model. */
+  static groq(options?: JsProviderOptions | undefined | null): Model
+  /** Create a Together AI completion model. */
+  static together(options?: JsProviderOptions | undefined | null): Model
+  /** Create a Mistral AI completion model. */
+  static mistral(options?: JsProviderOptions | undefined | null): Model
+  /** Create a `DeepSeek` completion model. */
+  static deepseek(options?: JsProviderOptions | undefined | null): Model
+  /** Create a Fireworks AI completion model. */
+  static fireworks(options?: JsProviderOptions | undefined | null): Model
+  /** Create a Perplexity completion model. */
+  static perplexity(options?: JsProviderOptions | undefined | null): Model
+  /** Create an xAI (Grok) completion model. */
+  static xai(options?: JsProviderOptions | undefined | null): Model
+  /** Create a Cohere completion model. */
+  static cohere(options?: JsProviderOptions | undefined | null): Model
+  /** Create an AWS Bedrock completion model. */
+  static bedrock(options: JsBedrockOptions): Model
+  /**
+   * Create a local Ollama completion model.
+   *
+   * Talks to a running Ollama server (defaults to `http://host:port/v1`).
+   * No API key is required.
+   *
+   * ```javascript
+   * const model = Model.ollama("localhost", 11434, "llama3.1:8b");
+   * ```
+   */
+  static ollama(host: string, port: number, model: string): Model
+  /**
+   * Create a local LM Studio completion model.
+   *
+   * Talks to a running LM Studio server's OpenAI-compatible endpoint.
+   *
+   * ```javascript
+   * const model = Model.lmStudio("localhost", 1234, "my-model");
+   * ```
+   */
+  static lmStudio(host: string, port: number, model: string): Model
+  /**
+   * Create a generic OpenAI-compatible completion model.
+   *
+   * Drives any OpenAI-compatible chat-completions endpoint with the
+   * supplied [`JsOpenAiCompatConfig`].
+   *
+   * ```javascript
+   * const model = Model.openaiCompat("my-host", {
+   *   providerName: "my-host",
+   *   baseUrl: "https://api.example.com/v1",
+   *   apiKey: "sk-...",
+   *   defaultModel: "my-model",
+   * });
+   * ```
+   */
+  static openaiCompat(providerId: string, config: JsOpenAiCompatConfig): Model
+  /**
+   * Create a fully user-defined completion model backed by a JavaScript
+   * host object.
+   *
+   * `hostObject` must expose Blazen capability methods (e.g.
+   * `complete`, `stream`) using the camelCase trait-method names. The
+   * optional `providerId` is used for logging; defaults to `"custom"`.
+   *
+   * ```javascript
+   * class MyProvider {
+   *   async complete(request) { /* ... *\/ }
+   * }
+   * const model = Model.custom(new MyProvider(), "my-provider");
+   * ```
+   */
+  static custom(hostObject: object, providerId?: string | undefined | null): Model
+  /** Get the model ID. */
+  get modelId(): string
+  /**
+   * Wrap this model with automatic retry on transient failures.
+   *
+   * ```javascript
+   * const model = Model.openrouter({ apiKey: key });
+   * const withRetry = model.withRetry({ maxRetries: 3, initialDelayMs: 1000 });
+   * ```
+   */
+  withRetry(config?: JsRetryConfig | undefined | null): Model
+  /**
+   * Wrap this model with an in-memory response cache.
+   *
+   * Streaming requests are never cached and always delegate directly to the
+   * underlying model.
+   *
+   * ```javascript
+   * const cached = model.withCache({ ttlSeconds: 300, maxEntries: 1000 });
+   * ```
+   */
+  withCache(config?: JsCacheConfig | undefined | null): Model
+  /**
+   * Create a fallback model that tries multiple providers in order.
+   *
+   * When the primary provider fails with a transient error (rate limit,
+   * timeout, server error) the request is automatically forwarded to the
+   * next provider. Non-retryable errors short-circuit immediately.
+   *
+   * ```javascript
+   * const model = Model.withFallback([modelA, modelB]);
+   * ```
+   */
+  static withFallback(models: Array<Model>): Model
+  /**
+   * Perform a chat completion.
+   *
+   * Messages should be an array of `ChatMessage` instances.
+   *
+   * Returns a typed response with `content`, `toolCalls`, `usage`, `model`,
+   * and `finishReason` fields.
+   */
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
+  /**
+   * Perform a chat completion with additional options.
+   *
+   * Options object may include:
+   * - `temperature` (number): Sampling temperature (0.0 - 2.0)
+   * - `maxTokens` (number): Maximum tokens to generate
+   * - `topP` (number): Nucleus sampling parameter
+   * - `model` (string): Override the default model
+   * - `tools` (array): Tool definitions for function calling
+   */
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
+  /**
+   * Stream a chat completion.
+   *
+   * The `onChunk` callback receives each chunk as a typed `StreamChunk` with
+   * `delta`, `finishReason`, and `toolCalls` fields.
+   *
+   * ```javascript
+   * await model.stream(
+   *   [ChatMessage.user("Tell me a story")],
+   *   (chunk) => { if (chunk.delta) process.stdout.write(chunk.delta); }
+   * );
+   * ```
+   */
+  stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
+  /**
+   * Stream a chat completion with additional options.
+   *
+   * Options object may include:
+   * - `temperature` (number): Sampling temperature (0.0 - 2.0)
+   * - `maxTokens` (number): Maximum tokens to generate
+   * - `topP` (number): Nucleus sampling parameter
+   * - `model` (string): Override the default model
+   * - `tools` (array): Tool definitions for function calling
+   */
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
+  /**
+   * Explicitly load the model weights into memory / `VRAM`.
+   *
+   * For remote providers (`OpenAI`, Anthropic, fal, etc.) this throws --
+   * there is no local model to load. For local providers (mistral.rs,
+   * llama.cpp, candle) this triggers the download + load synchronously,
+   * so the next inference call does not pay the startup cost.
+   *
+   * Idempotent: calling `load` on an already-loaded model is a no-op
+   * that resolves immediately.
+   */
+  load(): Promise<void>
+  /**
+   * Drop the loaded model and free its memory / `VRAM`.
+   *
+   * For remote providers this throws. For local providers this frees
+   * `GPU` memory so the process can load a different model. Idempotent.
+   */
+  unload(): Promise<void>
+  /**
+   * Whether the model is currently loaded in memory / `VRAM`.
+   *
+   * Always returns `false` for remote providers (they have no local
+   * model to load). Returns the real state for local providers.
+   */
+  isLoaded(): Promise<boolean>
+  /**
+   * Approximate memory footprint in bytes (host RAM if the
+   * provider targets the CPU, GPU VRAM otherwise), if the
+   * implementation can report it. Returns `null` for remote
+   * providers or for local providers that do not expose memory
+   * usage.
+   *
+   * Note: napi-rs exposes this as a JS `number`. The underlying
+   * [`blazen_llm::LocalModel::memory_bytes`] returns `u64`; we clamp
+   * to `i64::MAX` (~9.2 exabytes) when surfacing through
+   * `JSON`-compatible types, which is effectively lossless for any
+   * realistic footprint.
+   */
+  memoryBytes(): Promise<number | null>
+  /**
+   * Create a local mistral.rs completion model.
+   *
+   * Runs LLM inference entirely on-device -- no API key required.
+   *
+   * ```javascript
+   * const model = Model.mistralrs({
+   *   modelId: "mistralai/Mistral-7B-Instruct-v0.3",
+   * });
+   * ```
+   */
+  static mistralrs(options: JsMistralRsOptions): Model
+  /**
+   * Wrap this model in a [`TracingModel`] that emits a
+   * structured `tracing` span around every `complete` and `stream`
+   * call.
+   *
+   * `name` is recorded on the span as the `provider` field plus the
+   * `OpenInference` / `gen_ai.*` aliases (`gen_ai.system`, etc.). It is
+   * leaked into a `&'static str` because the underlying span macro
+   * captures it by reference for the process lifetime; this is
+   * intentional and bounded by the small set of distinct provider
+   * names a typical application uses.
+   *
+   * `captureMessages` (default `false`) opts into recording the raw
+   * prompt + completion text as `llm.input_messages` /
+   * `llm.output_messages` for Phoenix eval-grade ingest. Leave off for
+   * privacy-sensitive deployments.
+   *
+   * ```javascript
+   * const traced = Model.openai({ apiKey }).withTracing("openai");
+   * const evalGrade = Model.openai({ apiKey }).withTracing("openai", true);
+   * ```
+   */
+  withTracing(name: string, captureMessages?: boolean | undefined | null): Model
+  /**
+   * Wrap this model in a [`TracingModel`] using an explicit
+   * [`TracingConfig`](JsTracingConfig) object.
+   *
+   * Equivalent to [`with_tracing`](Self::with_tracing) but takes the
+   * structured config record (`{ captureMessages?: boolean }`) instead of
+   * a positional boolean. `name` is leaked into a `&'static str` for the
+   * span macro, exactly as in [`with_tracing`](Self::with_tracing).
+   *
+   * ```javascript
+   * const traced = Model.openai({ apiKey })
+   *   .withTracingConfig("openai", { captureMessages: true });
+   * ```
+   */
+  withTracingConfig(name: string, config: TracingConfig): Model
+}
+export type JsModel = Model
+
+/**
+ * Local cache for ML models downloaded from `HuggingFace` Hub.
+ *
+ * Models are stored under `{cacheDir}/{repoId}/{filename}`. Files are
+ * downloaded only once; subsequent calls return the cached path immediately.
+ *
+ * ```javascript
+ * import { ModelCache } from 'blazen';
+ *
+ * const cache = ModelCache.create();
+ * if (!cache.isCached('bert-base-uncased', 'config.json')) {
+ *   await cache.download('bert-base-uncased', 'config.json', (downloaded, total) => {
+ *     if (total !== null) {
+ *       console.log(`${(downloaded / total * 100).toFixed(1)}%`);
+ *     }
+ *   });
+ * }
+ * ```
+ */
+export declare class ModelCache {
+  /**
+   * Create a cache in the default location.
+   *
+   * Uses `$BLAZEN_CACHE_DIR/models/` if set, otherwise falls back to
+   * `~/.cache/blazen/models/`.
+   */
+  static create(): ModelCache
+  /**
+   * Create a cache rooted at a specific directory.
+   *
+   * The directory does not need to exist yet; it will be created on the
+   * first download.
+   */
+  static withDir(path: string): ModelCache
+  /** The root cache directory path as a string. */
+  get cacheDir(): string
+  /** Check if a file is already present in the cache (without downloading). */
+  isCached(repo: string, file: string): boolean
+  /**
+   * Download a file from `HuggingFace` Hub if it is not already cached.
+   *
+   * Returns the local filesystem path to the cached file.
+   *
+   * The optional `onProgress` argument accepts either:
+   * - A raw callback `(downloaded: number, total: number | null) => void`
+   *   for a quick inline progress hook, or
+   * - A [`JsProgressCallback`] subclass instance (recommended for stateful
+   *   reporters), whose `onProgress(downloaded, total)` method receives
+   *   byte counts as `bigint` values.
+   *
+   * `total` is `null` when the server does not report the file size up
+   * front.
+   */
+  download(repo: string, file: string, onProgress?: ProgressTsfn | object | undefined | null): Promise<string>
+}
+export type JsModelCache = ModelCache
+
+/**
+ * gRPC client for the `BlazenModelServer` service.
+ *
+ * Connect with [`connect`](Self::connect) (plaintext) or
+ * [`connectWithTls`](Self::connect_with_tls) (TLS / mTLS), then issue
+ * RPCs. This wave exposes only the status RPCs; later waves add load /
+ * unload / completions / embeddings / media / blobs.
+ *
+ * ```typescript
+ * const client = await ModelClient.connect("http://model-server:50051");
+ * const status = await client.status();
+ * if (await client.isLoaded("gpt-oss-120b")) {
+ *   // ...
+ * }
+ * ```
+ */
+export declare class ModelClient {
+  /**
+   * Open a plaintext connection to a `BlazenModelServer` at
+   * `endpoint` (e.g. `"http://localhost:50051"`).
+   */
+  static connect(endpoint: string): Promise<ModelClient>
+  /**
+   * Open a TLS (or mTLS, when `opts.clientCert` + `opts.clientKey`
+   * are supplied) connection to a `BlazenModelServer` at `endpoint`.
+   */
+  static connectWithTls(endpoint: string, opts: JsModelClientTlsOptions): Promise<ModelClient>
+  /**
+   * Fetch a snapshot of every registered model on the server.
+   *
+   * `model_id` is currently unused (the server returns every model
+   * either way) but is reserved for a future per-model filter. Pass
+   * `undefined` / omit the argument for the full snapshot.
+   *
+   * Returns a plain JS object with the wire shape of
+   * [`StatusResponse`] (`{ envelopeVersion, models: [...] }`),
+   * produced via `serde_json` so the model + adapter wires serialize
+   * recursively without per-field napi glue.
+   */
+  status(modelId?: string): Promise<any>
+  /** Liveness check for a specific registered model. */
+  isLoaded(modelId: string): Promise<boolean>
+  /**
+   * Issue a `Load` RPC for a previously-registered model.
+   *
+   * `request` is a plain JS object matching the wire shape of
+   * [`LoadRequest`] (`{ envelopeVersion?, modelId }`). The
+   * `envelopeVersion` field is filled in from
+   * [`MODEL_ENVELOPE_VERSION`] when omitted by the caller — pass the
+   * shorthand `{ modelId: "qwen3-7b" }` and the binding will set the
+   * rest. Returns the wire-shaped [`LoadResponse`] as a plain JS
+   * object.
+   */
+  load(request: any): Promise<any>
+  /**
+   * Issue an `Unload` RPC to drop a loaded model from memory.
+   *
+   * `request` mirrors [`UnloadRequest`] on the wire
+   * (`{ envelopeVersion?, modelId }`). Returns the wire-shaped
+   * [`UnloadResponse`] as a plain JS object.
+   */
+  unload(request: any): Promise<any>
+  /**
+   * Issue a `LoadFromHf` RPC — register-and-load a model from a
+   * Hugging Face Hub repo. Whether the server actually honors the
+   * request depends on it having been built with the `hf-loader`
+   * feature; the client speaks the wire either way.
+   *
+   * `request` matches [`LoadFromHfRequest`] on the wire
+   * (`{ envelopeVersion?, modelId, repo, memoryEstimateBytes?,
+   * backendHint?, ggufFile?, revision?, hfToken?,
+   * extraOptionsJson? }`). Returns the wire-shaped
+   * [`LoadFromHfResponse`] as a plain JS object.
+   */
+  loadFromHf(request: any): Promise<any>
+  /**
+   * Issue a `LoadAdapter` RPC.
+   *
+   * `request` matches [`LoadAdapterRequest`] on the wire. Returns the
+   * wire-shaped [`LoadAdapterResponse`] as a plain JS object.
+   */
+  loadAdapter(request: any): Promise<any>
+  /**
+   * Issue an `UnloadAdapter` RPC.
+   *
+   * `request` matches [`UnloadAdapterRequest`] on the wire. Returns the
+   * wire-shaped [`UnloadAdapterResponse`] as a plain JS object.
+   */
+  unloadAdapter(request: any): Promise<any>
+  /**
+   * Issue a `ListAdapters` RPC.
+   *
+   * `request` matches [`ListAdaptersRequest`] on the wire. Returns the
+   * wire-shaped [`ListAdaptersResponse`] as a plain JS object.
+   */
+  listAdapters(request: any): Promise<any>
+  /**
+   * Issue a `Complete` RPC.
+   *
+   * `request` matches [`CompleteRequest`] on the wire. Returns the
+   * wire-shaped [`CompleteResponse`] as a plain JS object.
+   */
+  complete(request: any): Promise<any>
+  /**
+   * Issue an `Embed` RPC.
+   *
+   * `request` matches [`EmbedRequest`] on the wire. Returns the
+   * wire-shaped [`EmbedResponse`] as a plain JS object.
+   */
+  embed(request: any): Promise<any>
+  /**
+   * Issue a `GenerateImage` RPC.
+   *
+   * `request` matches [`GenerateImageRequest`] on the wire. Returns the
+   * wire-shaped [`GenerateImageResponse`] as a plain JS object.
+   */
+  generateImage(request: any): Promise<any>
+  /**
+   * Issue a `TextToSpeech` RPC.
+   *
+   * `request` matches [`TextToSpeechRequest`] on the wire. Returns the
+   * wire-shaped [`TextToSpeechResponse`] as a plain JS object.
+   */
+  textToSpeech(request: any): Promise<any>
+  /**
+   * Issue a `GenerateMusic` RPC.
+   *
+   * `request` matches [`GenerateMusicRequest`] on the wire. Returns the
+   * wire-shaped [`GenerateMusicResponse`] as a plain JS object.
+   */
+  generateMusic(request: any): Promise<any>
+  /**
+   * Issue a `Transcribe` RPC.
+   *
+   * `request` matches [`TranscribeRequest`] on the wire. Returns the
+   * wire-shaped [`TranscribeResponse`] as a plain JS object.
+   */
+  transcribe(request: any): Promise<any>
+  /**
+   * Issue a `StreamComplete` server-streaming RPC.
+   *
+   * `request` matches [`CompleteRequest`] on the wire (same shape as
+   * the unary `complete` method). Returns a JS
+   * `AsyncIterableIterator` that yields wire-shaped
+   * [`StreamCompleteChunk`](blazen_controlplane::model_protocol::StreamCompleteChunk)
+   * objects (each a plain JS object — `{ kind: "delta", ... }` or
+   * `{ kind: "done", ... }` depending on the variant) until the
+   * server closes the stream.
+   *
+   * The stream is opened lazily on the first `next()` call so the
+   * initial RPC error (if any) surfaces to the consumer rather than
+   * to the synchronous call site.
    *
-   * The directory does not need to exist yet; it will be created on the
-   * first download.
+   * Mirrors the lazy-open `AsyncIterableIterator` pattern used by
+   * [`crate::controlplane::client::JsControlPlaneClient::subscribe_run_events`].
    */
-  static withDir(path: string): ModelCache
-  /** The root cache directory path as a string. */
-  get cacheDir(): string
-  /** Check if a file is already present in the cache (without downloading). */
-  isCached(repo: string, file: string): boolean
+  streamComplete(request: object): AsyncIterableIterator<object>
   /**
-   * Download a file from `HuggingFace` Hub if it is not already cached.
+   * Issue an `UploadBlob` client-streaming RPC.
    *
-   * Returns the local filesystem path to the cached file.
+   * `chunks` is the pre-collected blob payload split into one or more
+   * `Buffer` (or `Uint8Array`) pieces. The binding wraps them in the
+   * canonical `Start` / `Data*` / `End` frame sequence — callers do
+   * not need to construct envelope frames themselves. `options.blobId`
+   * names the upload (defaults to a freshly-generated UUID-shaped
+   * string when omitted); `options.mime` is forwarded as the
+   * `content_type` hint on the `Start` frame.
    *
-   * The optional `onProgress` argument accepts either:
-   * - A raw callback `(downloaded: number, total: number | null) => void`
-   *   for a quick inline progress hook, or
-   * - A [`JsProgressCallback`] subclass instance (recommended for stateful
-   *   reporters), whose `onProgress(downloaded, total)` method receives
-   *   byte counts as `bigint` values.
+   * This binding uses the **pre-collected `Vec<Buffer>`** approach
+   * rather than consuming a JS `AsyncIterable`: napi-rs does not yet
+   * surface a first-class JS-async-iterator → Rust-`Stream` adapter,
+   * and a hand-rolled `iterator.next()`-pumping bridge would have run
+   * well past the ~50-line budget called out in the wave plan. The
+   * streaming-over-the-wire shape (multiple postcard frames) is
+   * preserved — only the JS-side ergonomics differ from a true async
+   * iterable. Returns the wire-shaped [`UploadBlobResponse`] as a
+   * plain JS object.
+   */
+  uploadBlob(chunks: Array<Buffer | Uint8Array>, options?: { blobId?: string, mime?: string }): Promise<any>
+  /**
+   * Issue a `FetchBlob` server-streaming RPC.
    *
-   * `total` is `null` when the server does not report the file size up
-   * front.
+   * `request` matches [`FetchBlobRequest`] on the wire
+   * (`{ envelopeVersion?, blobId, offset?, chunkSize? }`). Returns a
+   * JS `AsyncIterableIterator<Buffer>` that yields the blob body in
+   * order — only the `Data` frames are surfaced as `Buffer` values;
+   * the `Start` / `End` envelope frames are consumed transparently
+   * (`Start` is dropped so callers see only bytes, `End` terminates
+   * iteration). The stream is opened lazily on the first `next()`
+   * call so the initial RPC error (if any) surfaces to the consumer.
+   *
+   * Mirrors the lazy-open pattern used by [`Self::stream_complete`].
    */
-  download(repo: string, file: string, onProgress?: ProgressTsfn | object | undefined | null): Promise<string>
+  fetchBlob(request: object): AsyncIterableIterator<Buffer>
 }
-export type JsModelCache = ModelCache
+export type JsModelClient = ModelClient
 
 /**
  * Memory-budget-aware model manager with per-pool LRU eviction.
@@ -3331,7 +3738,7 @@ export declare class ModelManager {
    */
   constructor(config?: ModelManagerConfig | undefined | null)
   /**
-   * Register a `CompletionModel`-backed local model with the manager.
+   * Register a `Model`-backed local model with the manager.
    *
    * The model starts in the unloaded state. An optional
    * `memoryEstimateBytes` overrides the model's self-reported
@@ -3343,11 +3750,11 @@ export declare class ModelManager {
    * tokenizer, custom runtime, …), use
    * [`Self::register_local_model`] instead.
    */
-  register(id: string, model: JsCompletionModel, memoryEstimateBytes?: bigint | undefined | null): Promise<void>
+  register(id: string, model: JsModel, memoryEstimateBytes?: bigint | undefined | null): Promise<void>
   /**
    * Register an arbitrary JS-managed local model with the manager.
    *
-   * Unlike [`Self::register`] — which expects a [`JsCompletionModel`]
+   * Unlike [`Self::register`] — which expects a [`JsModel`]
    * backed by an in-process provider — this entrypoint takes raw
    * lifecycle callbacks. The manager will invoke `load()` when the
    * model is brought into memory (potentially after evicting an LRU
@@ -3377,10 +3784,14 @@ export declare class ModelManager {
    * );
    * ```
    *
-   * `isLoaded`, `memoryEstimateBytes`, and `device` are all
-   * nullable / optional (pass `null` or `undefined` to omit).
+   * `isLoaded`, `memoryEstimateBytes`, `device`, `loadAdapter`,
+   * `unloadAdapter`, and `listAdapters` are all nullable / optional
+   * (pass `null` or `undefined` to omit). Omitted adapter callbacks
+   * cause [`JsModelManager::load_adapter`] / `unloadAdapter` /
+   * `listAdapters` to surface the upstream "backend does not support
+   * `LoRA` adapters" error for this model.
    */
-  registerLocalModel(id: string, load: LifecycleTsfn, unload: LifecycleTsfn, isLoaded?: IsLoadedTsfn | undefined | null, memoryEstimateBytes?: bigint | undefined | null, device?: string | undefined | null): Promise<void>
+  registerLocalModel(id: string, load: LifecycleTsfn, unload: LifecycleTsfn, isLoaded?: IsLoadedTsfn | undefined | null, memoryEstimateBytes?: bigint | undefined | null, device?: string | undefined | null, loadAdapter?: LoadAdapterTsfn | undefined | null, unloadAdapter?: UnloadAdapterTsfn | undefined | null, listAdapters?: ListAdaptersTsfn | undefined | null): Promise<void>
   /**
    * Load a model, evicting LRU peers in the same pool if the budget
    * would be exceeded.
@@ -3424,6 +3835,161 @@ export declare class ModelManager {
   pools(): Array<JsPoolBudget>
   /** Status of all registered models. */
   status(): Promise<Array<JsModelStatus>>
+  /**
+   * Auto-detect the right local-inference backend for a Hugging Face
+   * repo, then register and budget the model with this manager.
+   *
+   * Performs a single metadata request against the Hub to enumerate
+   * the repo's siblings, picks a backend (mistral.rs / candle /
+   * llama.cpp) per the rules documented on
+   * [`blazen_manager::hf_loader::choose_backend`], computes a memory
+   * estimate from the sibling sizes, and registers the model under
+   * `id`. The model starts unloaded — call [`Self::load`] or
+   * [`Self::ensure_loaded`] to materialize it.
+   *
+   * Returns the chosen backend as a lower-case string
+   * (`"mistralrs"` / `"candle"` / `"llamacpp"`).
+   *
+   * Throws on empty repo id, gated/missing repo, PEFT-adapter-only
+   * repo (use [`Self::load_adapter`] instead), missing backend
+   * feature, or any provider construction failure.
+   * Mount a PEFT-format `LoRA` adapter onto a registered model.
+   *
+   * `adapterDir` must contain the canonical PEFT layout
+   * (`adapter_model.safetensors` + `adapter_config.json`). The base
+   * model is implicitly loaded (`ensureLoaded`) before mounting.
+   *
+   * Returns the adapter id assigned by the backend (echoes
+   * `options.adapterId`).
+   *
+   * Throws if the model is not registered, the adapter id is already
+   * mounted, the pool budget would be exceeded, or the backend does
+   * not support adapters.
+   */
+  loadAdapter(modelId: string, adapterDir: string, options: AdapterOptions): Promise<string>
+  /**
+   * Unmount a previously-loaded adapter from a registered model.
+   *
+   * Throws if the model is not registered or the adapter id is not
+   * currently mounted on it.
+   */
+  unloadAdapter(modelId: string, adapterId: string): Promise<void>
+  /**
+   * List adapters currently mounted on a registered model.
+   *
+   * Throws if the model is not registered.
+   */
+  listAdapters(modelId: string): Promise<Array<JsAdapterStatus>>
+  /**
+   * Load a model from Hugging Face by repo id.
+   *
+   * Inspects the repo's siblings, picks a backend (mistral.rs /
+   * candle / llama.cpp) per the rules documented on
+   * [`blazen_manager::hf_loader::choose_backend`], computes a memory
+   * estimate from the sibling sizes, and registers the model under
+   * `id`. The model starts unloaded — call [`Self::load`] or
+   * [`Self::ensure_loaded`] to materialize it.
+   *
+   * Returns the chosen backend as a lower-case string
+   * (`"mistralrs"` / `"candle"` / `"llamacpp"`).
+   */
+  loadFromHf(id: string, repo: string, options?: JsHfLoadOptions | undefined | null): Promise<string>
+  /**
+   * Train a `LoRA` adapter end-to-end on the configured base model.
+   *
+   * Downloads the base model from HuggingFace (cached), builds a
+   * VarMap, runs the AdamW + LoRA training loop driven by `dataset`,
+   * and writes the resulting PEFT-format adapter to
+   * `config.outputDir`. The returned `TrainedAdapter`'s `adapterDir`
+   * is immediately mountable via [`Self::load_adapter`] on a
+   * compatible backend.
+   *
+   * `progress`, when supplied, is invoked once per Started /
+   * StepCompleted / Evaluating / EvalCompleted / CheckpointSaved /
+   * Finished transition. The return value is ignored; throwing
+   * inside the callback does not abort the run. A failure to queue
+   * the call (closed function, etc.) cancels the run with a
+   * `BlazenError::cancelled`.
+   *
+   * # Errors
+   *
+   * Throws on invalid config, unrecognised device, HF download
+   * failure, dataset I/O failure, trainer failure, or queueing
+   * failure on the progress callback.
+   */
+  trainLora(config: JsTrainConfig, dataset: JsonlDataset, progress?: ProgressTsfn | undefined | null): Promise<TrainedAdapter>
+  /**
+   * Train a `LoRA` adapter via Direct Preference Optimization (DPO).
+   *
+   * Like [`Self::train_lora`] but consumes a preference-pair dataset
+   * of `(prompt, chosen, rejected)` triples and requires a frozen
+   * reference model (defaults to `config.core.baseModelRepo` when
+   * `config.referenceModelRepo` is `null`).
+   *
+   * # Errors
+   *
+   * Throws on invalid config, unrecognised device, HF download
+   * failure, dataset I/O failure, trainer failure, or queueing
+   * failure on the progress callback.
+   */
+  trainDpo(config: JsDpoConfig, dataset: PreferenceJsonlDataset, progress?: ProgressTsfn | undefined | null): Promise<TrainedAdapter>
+  /**
+   * Train a `LoRA` adapter via Odds Ratio Preference Optimization (ORPO).
+   *
+   * Reference-free; combines a standard SFT loss on chosen
+   * completions with an odds-ratio preference term weighted by
+   * `config.lambda`.
+   *
+   * # Errors
+   *
+   * Same surface as [`Self::train_dpo`].
+   */
+  trainOrpo(config: JsOrpoConfig, dataset: PreferenceJsonlDataset, progress?: ProgressTsfn | undefined | null): Promise<TrainedAdapter>
+  /**
+   * Train a `LoRA` adapter via Simple Preference Optimization (`SimPO`).
+   *
+   * Reference-free and length-normalized. `config.beta` scales the
+   * preference logits and `config.gamma` sets the target reward
+   * margin.
+   *
+   * # Errors
+   *
+   * Same surface as [`Self::train_dpo`].
+   */
+  trainSimpo(config: JsSimpoConfig, dataset: PreferenceJsonlDataset, progress?: ProgressTsfn | undefined | null): Promise<TrainedAdapter>
+  /**
+   * Train a `LoRA` adapter via Kahneman-Tversky Optimization (KTO).
+   *
+   * Like DPO, KTO requires a frozen reference model — but the
+   * dataset schema differs: each row is a
+   * `(prompt, completion, desirable)` triple
+   * ([`JsRatedJsonlDataset`]), not a chosen/rejected pair.
+   *
+   * # Errors
+   *
+   * Same surface as [`Self::train_dpo`].
+   */
+  trainKto(config: JsKtoConfig, dataset: RatedJsonlDataset, progress?: ProgressTsfn | undefined | null): Promise<TrainedAdapter>
+  /**
+   * Run a full fine-tune (every parameter trainable; no `LoRA`
+   * adapter).
+   *
+   * Returns [`JsFullFineTuneResult`] — not [`JsTrainedAdapter`] —
+   * because the output is a complete set of model weights in
+   * `config.core.outputDir` rather than a mountable PEFT delta.
+   *
+   * Setting `config.gradientCheckpointing = true` is rejected at
+   * init time because candle 0.10.2 has no activation-checkpointing
+   * primitive.
+   *
+   * # Errors
+   *
+   * Throws on invalid config, unrecognised device,
+   * `gradientCheckpointing = true`, HF download failure, dataset
+   * I/O failure, trainer failure, or queueing failure on the
+   * progress callback.
+   */
+  fineTune(config: JsFullFineTuneConfig, dataset: JsonlDataset, progress?: ProgressTsfn | undefined | null): Promise<FullFineTuneResult>
 }
 export type JsModelManager = ModelManager
 
@@ -3460,6 +4026,137 @@ export declare class ModelRegistry {
 }
 export type JsModelRegistry = ModelRegistry
 
+/**
+ * Typed handle wrapping a `MusicGen` text-to-music backend.
+ *
+ * Mirrors [`blazen_llm::MusicBackendHandle`]. Construct it directly to
+ * get a default-configured `MusicGen` handle; weights load lazily on
+ * first generation.
+ */
+export declare class MusicBackendHandle {
+  /** Build a default-configured `MusicGen` music backend handle. */
+  constructor()
+  /** The wrapped backend's stable identifier. */
+  get id(): string
+}
+export type JsMusicBackendHandle = MusicBackendHandle
+
+/**
+ * MusicGen text-to-music + text-to-SFX backend.
+ *
+ * Use the [`JsMusicgenBackend::create`] factory to construct an instance.
+ */
+export declare class MusicgenBackend {
+  /**
+   * Construct a MusicGen backend handle.
+   *
+   * # Errors
+   * Returns the resulting `napi::Error` if option conversion fails;
+   * in practice always succeeds.
+   */
+  static create(options?: JsMusicgenOptions | undefined | null): MusicgenBackend
+  /** Backend identifier, e.g. `"musicgen-small"`. */
+  get modelId(): string
+  /**
+   * Generate music conditioned on `prompt`.
+   *
+   * # Errors
+   * Returns `MusicInvalidInputError` for empty prompts or non-positive
+   * / out-of-range durations, `MusicHfHubError` on weight-download
+   * failure, `MusicCandleError` on inference failure, or
+   * `MusicEngineNotAvailableError` when the engine feature was
+   * compiled out.
+   */
+  generateMusic(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Generate sound-effect audio conditioned on `prompt`.
+   *
+   * MusicGen treats music and SFX as the same autoregressive pipeline
+   * (the prompt is the only discriminator).
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`].
+   */
+  generateSfx(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Stream music generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`].
+   */
+  streamGenerateMusic(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+  /**
+   * Stream SFX generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`].
+   */
+  streamGenerateSfx(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+}
+export type JsMusicgenBackend = MusicgenBackend
+
+/**
+ * Unified music + SFX backend aggregator.
+ *
+ * ```javascript
+ * // Pick a backend at construction time:
+ * const m = MusicModel.musicgen({ variant: "small" });
+ * const wav = await m.generateMusic("uplifting piano", 8);
+ *
+ * // Or swap to AudioGen / Stable Audio with the same method surface:
+ * const sfx = MusicModel.audioGen({});
+ * const ambient = MusicModel.stableAudio({});
+ * ```
+ */
+export declare class MusicModel {
+  /** Build a [`JsMusicModel`] backed by MusicGen. */
+  static musicgen(options?: JsMusicgenOptions | undefined | null): MusicModel
+  /** Build a [`JsMusicModel`] backed by AudioGen. */
+  static audioGen(options?: JsAudioGenOptions | undefined | null): MusicModel
+  /** Build a [`JsMusicModel`] backed by Stable Audio Open. */
+  static stableAudio(options?: JsStableAudioOptions | undefined | null): MusicModel
+  /**
+   * Backend identifier — same value `modelId` returns on the per-
+   * backend `#[napi]` class (e.g. `"musicgen-small"`,
+   * `"audiogen-medium"`, `"stable-audio"`).
+   */
+  get modelId(): string
+  /**
+   * Generate music conditioned on `prompt`.
+   *
+   * # Errors
+   * See per-backend documentation
+   * ([`JsMusicgenBackend::generate_music`], etc.).
+   */
+  generateMusic(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Generate sound-effect audio conditioned on `prompt`.
+   *
+   * # Errors
+   * See per-backend documentation.
+   */
+  generateSfx(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Stream music generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * See per-backend documentation.
+   */
+  streamGenerateMusic(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+  /**
+   * Stream SFX generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * See per-backend documentation.
+   */
+  streamGenerateSfx(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+}
+export type JsMusicModel = MusicModel
+
 /**
  * r" Base class for music generation providers.
  * r"
@@ -3490,7 +4187,7 @@ export type JsMusicProvider = MusicProvider
  * Useful as a default when no downstream observer is wired up:
  *
  * ```javascript
- * const model = new UsageRecordingCompletionModel(base, new NoopUsageEmitter(), "openai");
+ * const model = new UsageRecordingModel(base, new NoopUsageEmitter(), "openai");
  * ```
  */
 export declare class NoopUsageEmitter {
@@ -3534,13 +4231,13 @@ export declare class OpenAiCompatProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsOpenAiCompatProvider = OpenAiCompatProvider
 
@@ -3572,7 +4269,7 @@ export type JsOpenAiEmbeddingModel = OpenAiEmbeddingModel
  * An `OpenAI` compute provider exposing text-to-speech.
  *
  * For chat completions and embeddings, use
- * [`CompletionModel.openai`](crate::providers::completion_model::JsCompletionModel::openai)
+ * [`Model.openai`](crate::providers::model::JsModel::openai)
  * instead — this class is the standalone entry point for the compute
  * capabilities (currently text-to-speech) that the `OpenAI` provider
  * implements directly.
@@ -3607,13 +4304,13 @@ export declare class OpenRouterProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsOpenRouterProvider = OpenRouterProvider
 
@@ -3733,13 +4430,13 @@ export declare class PerplexityProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsPerplexityProvider = PerplexityProvider
 
@@ -3750,6 +4447,15 @@ export declare class Pipeline {
    * Consumes the pipeline -- calling start/resume a second time errors.
    */
   start(input: any): Promise<PipelineHandler>
+  /**
+   * Execute the pipeline and await its final result in one call.
+   *
+   * This is the result-shorthand mirror of [`crate::workflow::JsWorkflow::run`]:
+   * equivalent to `(await pipeline.start(input)).result()`, but without
+   * exposing the intermediate handler. Consumes the pipeline -- calling
+   * `run`/`start`/`resume` a second time errors.
+   */
+  run(input: any): Promise<JsPipelineResult>
   /**
    * Inspect the pipeline-level default retry configuration, if any.
    * Mirrors [`blazen_pipeline::Pipeline::retry_config`] (Wave 2).
@@ -3771,6 +4477,14 @@ export declare class PipelineBuilder {
   stage(stage: JsStage): this
   /** Append a `ParallelStage` to the pipeline. */
   parallel(parallel: JsParallelStage): this
+  /**
+   * Append a `LoopStage` to the pipeline.
+   *
+   * The loop re-runs its inner stage up to `maxIterations` times (see the
+   * [`LoopStage`](crate::pipeline::loop_stage::JsLoopStage) docs for the v1
+   * iteration semantics). The `loopStage` instance is consumed.
+   */
+  loopStage(loopStage: JsLoopStage): this
   /** Set a per-stage timeout in seconds. Each stage's workflow gets this duration. */
   timeoutPerStage(seconds: number): this
   /**
@@ -3845,6 +4559,36 @@ export declare class PipelineHandler {
    * Returns `null` after [`Self::result`] has consumed the handler.
    */
   progress(): Promise<JsProgressSnapshot | null>
+  /**
+   * Respond to an input request from a stage that is paused on an
+   * `InputRequestEvent`. The response is fanned out to the active
+   * stage's inner workflow(s). Mirrors
+   * [`blazen_pipeline::PipelineHandler::respond_to_input`].
+   *
+   * The `request_id` must match the `InputRequestEvent.request_id` that
+   * was published by a step inside the running stage.
+   */
+  respondToInput(requestId: string, response: any): Promise<void>
+  /**
+   * Respond to an input request using a typed [`JsInputResponseEvent`].
+   *
+   * Equivalent to [`Self::respond_to_input`] but accepts the typed
+   * event object so JS callers can pass a single value already shaped
+   * like the input-response event they may have built earlier.
+   */
+  respondToInputTyped(event: JsInputResponseEvent): Promise<void>
+  /**
+   * Aggregated token usage across the pipeline run so far. Mirrors
+   * [`blazen_pipeline::PipelineHandler::usage_total`]. Returns `null`
+   * after the handler has been consumed by [`Self::result`].
+   */
+  usageTotal(): Promise<JsTokenUsageClass | null>
+  /**
+   * Aggregated cost in USD across the pipeline run so far. Mirrors
+   * [`blazen_pipeline::PipelineHandler::cost_total_usd`]. Returns `null`
+   * after the handler has been consumed by [`Self::result`].
+   */
+  costTotalUsd(): Promise<number | null>
   /** Abort the pipeline. */
   abort(): Promise<void>
   /**
@@ -3852,7 +4596,7 @@ export declare class PipelineHandler {
    * The callback `(eventJson) => void` is invoked for each `PipelineEvent`;
    * `eventJson` is a JS object with shape `{ stageName, branchName, workflowRunId, event }`.
    */
-  streamEvents(onEvent: StreamCallbackTsfn): Promise<void>
+  streamEvents(onEvent: (event: { stageName: string; branchName: string; workflowRunId: string; event: Event }) => void): Promise<void>
 }
 export type JsPipelineHandler = PipelineHandler
 
@@ -3891,26 +4635,25 @@ export declare class PipelineSnapshot {
 export type JsPipelineSnapshot = PipelineSnapshot
 
 /**
- * A local Piper TTS provider.
+ * Preference-pair JSONL dataset for DPO / ORPO / SimPO.
  *
- * ```javascript
- * const provider = PiperProvider.create({
- *   modelId: "en_US-amy-medium",
- * });
- * ```
+ * Each line of the input file must deserialize to either
+ * `{"prompt": "...", "chosen": "...", "rejected": "..."}` or
+ * `{"messages": [...], "chosen": "...", "rejected": "..."}` (chat shape).
  */
-export declare class PiperProvider {
-  /** Create a new Piper provider. */
-  static create(options?: JsPiperOptions | undefined | null): PiperProvider
-  /** Get the configured voice model identifier, if any. */
-  get modelId(): string | null
+export declare class PreferenceJsonlDataset {
   /**
-   * Whether the engine feature is compiled in. When `false`,
-   * synthesis methods will return errors.
+   * Load a preference JSONL file using the tokenizer at
+   * `tokenizerPath`.
+   *
+   * # Errors
+   *
+   * Throws if the tokenizer cannot be loaded, the device string is
+   * invalid, or the JSONL file fails to parse.
    */
-  get engineAvailable(): boolean
+  static fromPath(path: string, tokenizerPath: string, opts?: JsJsonlDatasetOptions | undefined | null): PreferenceJsonlDataset
 }
-export type JsPiperProvider = PiperProvider
+export type JsPreferenceJsonlDataset = PreferenceJsonlDataset
 
 /**
  * Subclassable base for download progress callbacks.
@@ -4109,6 +4852,66 @@ export declare class PromptTemplate {
 }
 export type JsPromptTemplate = PromptTemplate
 
+/**
+ * Completion-role provider defaults: system prompt, default tools,
+ * `responseFormat`, and a typed `beforeModel` hook.
+ *
+ * ```javascript
+ * import { BaseProviderDefaults, ProviderDefaults } from "blazen";
+ *
+ * const d = new ProviderDefaults(
+ *   new BaseProviderDefaults(),
+ *   "Be terse.",
+ *   [], // default tools
+ *   { type: "json_object" },
+ *   async (request) => { /* mutate request *\/ },
+ * );
+ * ```
+ */
+export declare class ProviderDefaults {
+  /** Construct completion-role defaults. */
+  constructor(base?: BaseProviderDefaults | undefined | null, systemPrompt?: string | undefined | null, tools?: Array<JsToolDefinition> | undefined | null, responseFormat?: any | undefined | null, beforeModel?: BeforeModelTsfn | undefined | null)
+  /**
+   * The system prompt prepended to requests when the request itself
+   * carries no system message.
+   */
+  get systemPrompt(): string | null
+  /** Replace the system prompt. Pass `null` to clear. */
+  set systemPrompt(value: string | undefined | null)
+  /** The default tools appended to every completion request. */
+  get tools(): Array<JsToolDefinition>
+  /** Replace the default tools. */
+  set tools(value: Array<JsToolDefinition> | undefined | null)
+  /** Default `response_format` (JSON Schema or similar object). */
+  get responseFormat(): any | null
+  /** Replace the default `responseFormat`. Pass `null` to clear. */
+  set responseFormat(value: any | undefined | null)
+  /** Returns `true` when a `beforeModel` hook is configured. */
+  get hasBeforeCompletion(): boolean
+  /** Replace the typed `beforeModel` hook. Pass `null` to clear. */
+  set beforeModel(hook: BeforeModelTsfn | undefined | null)
+}
+export type JsProviderDefaults = ProviderDefaults
+
+/**
+ * Rated JSONL dataset for KTO.
+ *
+ * Each line of the input file must deserialize to
+ * `{"prompt"|"messages": ..., "completion": "...", "label": true|false}`.
+ */
+export declare class RatedJsonlDataset {
+  /**
+   * Load a rated JSONL file using the tokenizer at `tokenizerPath`.
+   *
+   * # Errors
+   *
+   * Throws if the tokenizer cannot be loaded, the device string is
+   * invalid, or the JSONL file fails to parse.
+   */
+  static fromPath(path: string, tokenizerPath: string, opts?: JsJsonlDatasetOptions | undefined | null): RatedJsonlDataset
+}
+export type JsRatedJsonlDataset = RatedJsonlDataset
+
 /**
  * Class wrapper around [`ReasoningTrace`].
  *
@@ -4182,67 +4985,25 @@ export declare class RegistryKey {
    * Alias for [`Self::render_uuid`] exposed as a getter so JS can do
    * `key.uuid` in addition to `key.toString()`.
    */
-  get uuid(): string
-}
-export type JsRegistryKey = RegistryKey
-
-/** Class wrapper around [`RequestTiming`]. */
-export declare class RequestTiming {
-  /** Construct a request-timing instance. */
-  constructor(options: RequestTimingOptions)
-  get queueMs(): number | null
-  get executionMs(): number | null
-  get totalMs(): number | null
-}
-export type JsRequestTimingClass = RequestTiming
-
-/**
- * A completion model that retries transient failures with exponential
- * backoff.
- *
- * ```javascript
- * const model = new RetryCompletionModel(
- *     CompletionModel.openrouter(),
- *     { maxRetries: 5, initialDelayMs: 500 },
- * );
- * const response = await model.complete([ChatMessage.user("hi")]);
- * ```
- */
-export declare class RetryCompletionModel {
-  /**
-   * Wrap `model` with retry-on-transient-error behaviour.
-   *
-   * `config` defaults to [`RetryConfig::default()`] (3 retries, 1s
-   * initial delay, 30s cap, jitter on, `Retry-After` honoured) when
-   * omitted.
-   */
-  constructor(model: CompletionModel, config?: JsRetryConfig | undefined | null)
-  /** The wrapped model's id. */
-  get modelId(): string
-  /** Perform a chat completion with automatic retries. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
-  /** Perform a chat completion with options and automatic retries. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
-  /**
-   * Stream a chat completion. Retries the initial request on transient
-   * failures; mid-stream errors are not retried.
-   */
-  stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
-  /** Stream a chat completion with options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
-  /**
-   * Convert this retry wrapper into a plain [`JsCompletionModel`] so
-   * it can be passed to APIs that expect the base type.
-   */
-  toCompletionModel(): CompletionModel
+  get uuid(): string
+}
+export type JsRegistryKey = RegistryKey
+
+/** Class wrapper around [`RequestTiming`]. */
+export declare class RequestTiming {
+  /** Construct a request-timing instance. */
+  constructor(options: RequestTimingOptions)
+  get queueMs(): number | null
+  get executionMs(): number | null
+  get totalMs(): number | null
 }
-export type JsRetryCompletionModel = RetryCompletionModel
+export type JsRequestTimingClass = RequestTiming
 
 /**
  * A `MemoryBackend` decorator that retries transient errors with
  * exponential backoff.
  *
- * Mirrors `RetryCompletionModel` for `MemoryBackend`. Use one of the
+ * Mirrors `RetryModel` for `MemoryBackend`. Use one of the
  * `wrapInMemory` / `wrapJsonl` / `wrapValkey` factories to wrap the
  * matching backend.
  *
@@ -4271,7 +5032,7 @@ export type JsRetryMemoryBackend = RetryMemoryBackend
 /**
  * Built-in middleware that wraps the inner model with retry-on-transient-
  * error behaviour. Equivalent to constructing a
- * [`super::wrappers::JsRetryCompletionModel`] but composable inside a
+ * [`super::wrappers::JsRetryModel`] but composable inside a
  * [`JsMiddlewareStack`].
  *
  * ```javascript
@@ -4294,6 +5055,115 @@ export declare class RetryMiddleware {
 }
 export type JsRetryMiddleware = RetryMiddleware
 
+/**
+ * A completion model that retries transient failures with exponential
+ * backoff.
+ *
+ * ```javascript
+ * const model = new RetryModel(
+ *     Model.openrouter(),
+ *     { maxRetries: 5, initialDelayMs: 500 },
+ * );
+ * const response = await model.complete([ChatMessage.user("hi")]);
+ * ```
+ */
+export declare class RetryModel {
+  /**
+   * Wrap `model` with retry-on-transient-error behaviour.
+   *
+   * `config` defaults to [`RetryConfig::default()`] (3 retries, 1s
+   * initial delay, 30s cap, jitter on, `Retry-After` honoured) when
+   * omitted.
+   */
+  constructor(model: Model, config?: JsRetryConfig | undefined | null)
+  /** The wrapped model's id. */
+  get modelId(): string
+  /** Perform a chat completion with automatic retries. */
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
+  /** Perform a chat completion with options and automatic retries. */
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
+  /**
+   * Stream a chat completion. Retries the initial request on transient
+   * failures; mid-stream errors are not retried.
+   */
+  stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
+  /** Stream a chat completion with options. */
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
+  /**
+   * Convert this retry wrapper into a plain [`JsModel`] so
+   * it can be passed to APIs that expect the base type.
+   */
+  toModel(): Model
+}
+export type JsRetryModel = RetryModel
+
+/**
+ * Retrieval-based Voice Conversion backend.
+ *
+ * Use the [`JsRvcBackend::create`] factory to construct an instance.
+ */
+export declare class RvcBackend {
+  /** Construct an RVC backend handle. */
+  static create(options?: JsRvcOptions | undefined | null): RvcBackend
+  /** Backend identifier, always `"rvc"`. */
+  get modelId(): string
+  /**
+   * Convert a source utterance to the voice of a registered target
+   * speaker, returning the rendered audio as a self-describing WAV
+   * payload + parsed sample-rate / duration metadata.
+   *
+   * # Errors
+   * Returns `VcVoiceNotFoundError` when `targetVoiceId` is not
+   * registered, `VcIoError` on file-read failures, `VcModelLoadError`
+   * on weight-load failures, `VcConversionError` on inference
+   * failures, or `VcEngineNotAvailableError` when the engine
+   * feature was compiled out.
+   */
+  convertVoice(inputAudioPath: string, targetVoiceId: string): Promise<JsVcResult>
+  /**
+   * Stream voice conversion over an in-memory PCM buffer, invoking
+   * `onChunk` for each emitted [`crate::vc::JsVcChunk`] until the
+   * stream ends (the last chunk arrives with `isFinal === true`).
+   *
+   * The input samples are wrapped in a single-item stream and fed to
+   * the backend's chunked streaming entry point; the backend
+   * internally buffers windows (typically 2 seconds at 16 kHz) and
+   * emits the converted PCM at the target voice's native sample
+   * rate.
+   *
+   * # Errors
+   * Same surface as [`Self::convert_voice`]; additionally surfaces
+   * `VcUnsupportedError` from a backend that does not support
+   * streaming (the default-impl path).
+   */
+  streamConvertPcm(inputSamples: Float32Array, targetVoiceId: string, onChunk: StreamVcChunkCallbackTsfn): Promise<void>
+  /**
+   * List the target voices this backend can currently render.
+   *
+   * # Errors
+   * Returns `VcUnsupportedError` from backends that don't expose a
+   * voice catalogue; `VcIoError` when probing the voice directory
+   * fails.
+   */
+  listTargetVoices(): Promise<Array<JsTargetVoice>>
+  /**
+   * Register a new target voice from a reference utterance.
+   *
+   * RVC voice registration is intentionally unsupported at runtime
+   * (training a voice profile requires an offline pipeline of 1+
+   * hours); this method therefore surfaces
+   * `VcUnsupportedError`. Pre-trained voice profiles can be placed
+   * under `$BLAZEN_RVC_VOICE_DIR/<voice_id>/` and will surface
+   * through [`Self::list_target_voices`] / [`Self::convert_voice`].
+   *
+   * # Errors
+   * Returns `VcUnsupportedError` from RVC; other backends may
+   * override this with a real implementation.
+   */
+  registerTargetVoice(voiceId: string, referenceAudioPath: string): Promise<void>
+}
+export type JsRvcBackend = RvcBackend
+
 /**
  * Namespace for in-process-only workflow values.
  *
@@ -4408,6 +5278,83 @@ export declare class SessionRefRegistry {
 }
 export type JsSessionRefRegistry = SessionRefRegistry
 
+/**
+ * The Spark-TTS backend.
+ *
+ * Mirrors [`blazen_llm::SparkTtsBackend`]. Construct with an optional
+ * [`SparkTtsConfig`](JsSparkTtsConfig); weights load lazily on first
+ * synthesis.
+ */
+export declare class SparkTtsBackend {
+  /**
+   * Build a Spark-TTS backend. No weights are loaded until the first
+   * synthesis call.
+   */
+  constructor(config?: SparkTtsConfig | undefined | null)
+  /** The configured model id. */
+  get modelId(): string
+  /** Wrap this backend in a typed [`TtsBackendHandle`]. */
+  intoHandle(): JsTtsBackendHandle
+}
+export type JsSparkTtsBackend = SparkTtsBackend
+
+/**
+ * Stable Audio Open backend.
+ *
+ * Use the [`JsStableAudioBackend::create`] factory to construct an
+ * instance. In stub mode (feature `audio-music-stable-audio` OFF), every
+ * `generate*` entry point surfaces `MusicNotYetImplementedError`.
+ */
+export declare class StableAudioBackend {
+  /**
+   * Construct a Stable Audio backend handle.
+   *
+   * In stub mode (`audio-music-stable-audio` OFF), the returned
+   * handle's `generate*` calls all surface
+   * `MusicNotYetImplementedError`. With the feature ON, the first
+   * `generate*` call lazily downloads weights and loads the model.
+   */
+  static create(options?: JsStableAudioOptions | undefined | null): StableAudioBackend
+  /** Backend identifier, always `"stable-audio"`. */
+  get modelId(): string
+  /**
+   * Generate music conditioned on `prompt`.
+   *
+   * # Errors
+   * Returns `MusicNotYetImplementedError` in stub mode (feature
+   * `audio-music-stable-audio` OFF). With the feature ON, may return
+   * `MusicInvalidInputError`, `MusicHfHubError`, or `MusicCandleError`.
+   */
+  generateMusic(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Generate sound-effect audio conditioned on `prompt`.
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`].
+   */
+  generateSfx(prompt: string, durationSeconds: number): Promise<JsMusicResult>
+  /**
+   * Stream music generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * Same surface as [`Self::generate_music`]. In stub mode (without
+   * the streaming path on the upstream trait), this surfaces
+   * `MusicNotYetImplementedError` because the trait default
+   * implementation routes there.
+   */
+  streamGenerateMusic(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+  /**
+   * Stream SFX generation, invoking `onChunk` for each emitted
+   * `JsMusicChunk` until the final chunk arrives (`isFinal === true`).
+   *
+   * # Errors
+   * Same surface as [`Self::stream_generate_music`].
+   */
+  streamGenerateSfx(prompt: string, durationSeconds: number, onChunk: StreamMusicChunkCallbackTsfn): Promise<void>
+}
+export type JsStableAudioBackend = StableAudioBackend
+
 /**
  * A single sequential pipeline stage.
  *
@@ -4614,9 +5561,9 @@ export type JsStepDeserializerRegistry = StepDeserializerRegistry
  */
 export declare class StepOutput {
   /** Construct a single-event output. */
-  static single(event: any): StepOutput
+  static single(event: Event): StepOutput
   /** Construct a fan-out output from an array of events. */
-  static multiple(events: Array<any>): StepOutput
+  static multiple(events: Array<Event>): StepOutput
   /** Construct a no-output result (side-effect only). */
   static none(): StepOutput
   /** Active variant tag. */
@@ -4699,7 +5646,7 @@ export type JsStopEventClass = StopEvent
  * Base class for the structured-output extraction surface.
  *
  * Mirrors [`blazen_llm::traits::StructuredOutput`]. Most callers should
- * use [`crate::providers::JsCompletionModel`]'s built-in structured
+ * use [`crate::providers::JsModel`]'s built-in structured
  * output (every completion model supports it via the blanket impl);
  * this class exists so users can write a custom `extract` that does
  * something different (e.g. multi-pass extraction, retries, custom
@@ -4716,6 +5663,100 @@ export declare class StructuredOutput {
 }
 export type JsStructuredOutput = StructuredOutput
 
+/**
+ * Typed handle wrapping a faster-whisper STT backend.
+ *
+ * Mirrors [`blazen_llm::SttBackendHandle`]. Obtain one from
+ * [`FasterWhisperBackend.intoHandle`](JsFasterWhisperBackend::into_handle).
+ */
+export declare class SttBackendHandle {
+  /** The wrapped backend's stable identifier. */
+  get id(): string
+  /** The wrapped backend's capability tag. */
+  get providerKind(): string
+  /** Load the wrapped backend's weights. */
+  load(): Promise<void>
+}
+export type JsSttBackendHandle = SttBackendHandle
+
+/**
+ * A user-defined child runner embeddable inside a parent `Workflow`.
+ *
+ * Subclass `SubExecutable` and override `execute(input)` to run an opaque
+ * JSON payload to completion, returning the terminal JSON value. The
+ * resulting object can be embedded as a step via `SubPipelineStep`'s
+ * `fromExecutable` factory.
+ *
+ * ```typescript
+ * import { SubExecutable, SubPipelineStep, Workflow } from "blazen";
+ *
+ * class Doubler extends SubExecutable {
+ *   async execute(input) {
+ *     return { value: input.value * 2 };
+ *   }
+ * }
+ *
+ * const step = SubPipelineStep.fromExecutable(
+ *   "double", ["blazen::StartEvent"], ["double::output"], new Doubler(),
+ * );
+ * ```
+ *
+ * Constructing `SubExecutable` directly (without a subclass override)
+ * yields a runner whose `execute` reports an error — override `execute` to
+ * give it behavior.
+ */
+export declare class SubExecutable {
+  /**
+   * Construct a `SubExecutable`.
+   *
+   * When invoked through a JS subclass that overrides `execute`, the
+   * constructor binds that override and dispatches every Rust
+   * [`SubExecutable::execute`](blazen_core::SubExecutable::execute) call
+   * to it. When invoked directly (no override), `execute` reports an
+   * error until overridden.
+   */
+  constructor()
+}
+export type JsSubExecutable = SubExecutable
+
+/**
+ * A workflow step that delegates to a `Pipeline`.
+ *
+ * The child pipeline is cloned (from a built [`Pipeline`](JsPipeline)) at
+ * construction time and stored as an `Arc<dyn SubExecutable>` so this step
+ * instance can be reused across multiple parent workflows.
+ */
+export declare class SubPipelineStep {
+  /**
+   * Create a sub-pipeline step.
+   *
+   * `name` / `accepts` / `emits` describe routing. `inner` is the child
+   * pipeline whose stages are run for each parent dispatch. The inner
+   * pipeline is cloned at construction time, so `inner` must not have
+   * been consumed (by `start`/`run`/`resume`) yet and this step instance
+   * can be reused across builders.
+   */
+  constructor(name: string, accepts: Array<string>, emits: Array<string>, inner: Pipeline, timeoutSecs?: number | undefined | null, retryConfig?: JsRetryConfig | undefined | null)
+  /**
+   * Create a sub-pipeline step from any [`SubExecutable`](JsSubExecutable)
+   * child runner.
+   *
+   * Unlike [`new`](Self::new) (which embeds a built `Pipeline`), this
+   * accepts a user-defined `SubExecutable` subclass instance, letting an
+   * arbitrary JS-implemented child runner be embedded inside a parent
+   * `Workflow`. The executable handle is cloned, so the instance can be
+   * reused across builders.
+   */
+  static fromExecutable(name: string, accepts: Array<string>, emits: Array<string>, executable: SubExecutable, timeoutSecs?: number | undefined | null, retryConfig?: JsRetryConfig | undefined | null): SubPipelineStep
+  /** The step name. */
+  get name(): string
+  /** Event type identifiers this step accepts. */
+  get accepts(): Array<string>
+  /** Event type identifiers this step may emit. */
+  get emits(): Array<string>
+}
+export type JsSubPipelineStep = SubPipelineStep
+
 /**
  * A workflow step that delegates to another `Workflow`.
  *
@@ -4825,13 +5866,13 @@ export declare class TogetherProvider {
    */
   static embeddingModel(options?: JsProviderOptions | undefined | null): OpenAiCompatEmbeddingModel
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsTogetherProvider = TogetherProvider
 
@@ -5099,6 +6140,42 @@ export declare class TranscriptionProviderDefaults {
 }
 export type JsTranscriptionProviderDefaults = TranscriptionProviderDefaults
 
+/**
+ * Typed handle wrapping a Spark-TTS backend.
+ *
+ * Mirrors [`blazen_llm::TtsBackendHandle`]. Obtain one from
+ * [`SparkTtsBackend.intoHandle`](JsSparkTtsBackend::into_handle).
+ */
+export declare class TtsBackendHandle {
+  /** The wrapped backend's stable identifier. */
+  get id(): string
+}
+export type JsTtsBackendHandle = TtsBackendHandle
+
+/**
+ * A local TTS provider backed by `any-tts`.
+ *
+ * ```javascript
+ * const provider = TtsProvider.create({
+ *   model: "kokoro82m",
+ *   voice: "af_bella",
+ * });
+ * ```
+ */
+export declare class TtsProvider {
+  /** Create a new TTS provider. */
+  static create(options?: JsTtsOptions | undefined | null): TtsProvider
+  /** The configured model kind, as a string (`"kokoro"`, `"vibevoice"`, `"qwen3_tts"`). */
+  get model(): string
+  /**
+   * Whether the engine feature is compiled in. When the `anytts`
+   * feature is on, this returns `true` — the provider can be
+   * constructed regardless of the runtime model-load outcome.
+   */
+  get engineAvailable(): boolean
+}
+export type JsTtsProvider = TtsProvider
+
 /**
  * r" Base class for text-to-speech providers.
  * r"
@@ -5211,7 +6288,7 @@ export type JsUpstashBackend = UpstashBackend
  * ```javascript
  * const events: UsageEvent[] = [];
  * const emitter = new UsageEmitter((event) => { events.push(event); });
- * const model = new UsageRecordingCompletionModel(base, emitter, "openai");
+ * const model = new UsageRecordingModel(base, emitter, "openai");
  * ```
  */
 export declare class UsageEmitter {
@@ -5224,44 +6301,44 @@ export declare class UsageEmitter {
 export type JsUsageEmitter = UsageEmitter
 
 /**
- * A `CompletionModel` decorator that emits a `UsageEvent` after each
+ * An `EmbeddingModel` decorator that emits a `UsageEvent` after each
+ * successful `embed` call.
+ */
+export declare class UsageRecordingEmbeddingModel {
+  /** Wrap an `EmbeddingModel` with a usage-recording layer. */
+  constructor(model: EmbeddingModel, emitter: AnyEmitter, providerLabel: string, runId?: string | undefined | null)
+  /** The underlying provider's model id. */
+  get modelId(): string
+  /** Output dimensionality. */
+  get dimensions(): number
+}
+export type JsUsageRecordingEmbeddingModel = UsageRecordingEmbeddingModel
+
+/**
+ * A `Model` decorator that emits a `UsageEvent` after each
  * successful `complete` call. Mirrors
- * `blazen_llm::usage_recording::UsageRecordingCompletionModel`.
+ * `blazen_llm::usage_recording::UsageRecordingModel`.
  *
  * ```javascript
- * const base = CompletionModel.openai();
+ * const base = Model.openai();
  * const events = [];
  * const emitter = new UsageEmitter((e) => events.push(e));
- * const model = new UsageRecordingCompletionModel(base, emitter, "openai");
+ * const model = new UsageRecordingModel(base, emitter, "openai");
  * const response = await model.complete([ChatMessage.user("hi")]);
  * ```
  */
-export declare class UsageRecordingCompletionModel {
-  /** Wrap a `CompletionModel` with a usage-recording layer. */
-  constructor(model: CompletionModel, emitter: AnyEmitter, providerLabel: string, runId?: string | undefined | null)
+export declare class UsageRecordingModel {
+  /** Wrap a `Model` with a usage-recording layer. */
+  constructor(model: Model, emitter: AnyEmitter, providerLabel: string, runId?: string | undefined | null)
   /** The underlying provider's model id. */
   get modelId(): string
   /**
-   * Convert this decorator into a `CompletionModel` so it can be passed to
+   * Convert this decorator into a `Model` so it can be passed to
    * APIs that expect the base type (`runAgent`, further decorators, …).
    */
-  toCompletionModel(): CompletionModel
+  toModel(): Model
 }
-export type JsUsageRecordingCompletionModel = UsageRecordingCompletionModel
-
-/**
- * An `EmbeddingModel` decorator that emits a `UsageEvent` after each
- * successful `embed` call.
- */
-export declare class UsageRecordingEmbeddingModel {
-  /** Wrap an `EmbeddingModel` with a usage-recording layer. */
-  constructor(model: EmbeddingModel, emitter: AnyEmitter, providerLabel: string, runId?: string | undefined | null)
-  /** The underlying provider's model id. */
-  get modelId(): string
-  /** Output dimensionality. */
-  get dimensions(): number
-}
-export type JsUsageRecordingEmbeddingModel = UsageRecordingEmbeddingModel
+export type JsUsageRecordingModel = UsageRecordingModel
 
 /**
  * A Valkey/Redis-backed backend for the memory store.
@@ -5319,6 +6396,87 @@ export declare class ValkeyCheckpointStore {
 }
 export type JsValkeyCheckpointStore = ValkeyCheckpointStore
 
+/**
+ * Unified voice-conversion backend aggregator.
+ *
+ * ```javascript
+ * // Pick a backend at construction time:
+ * const m = VcModel.rvc({ topK: 8, retrievalBlend: 0.75 });
+ * const result = await m.convertVoice('input.wav', 'speaker-01');
+ * ```
+ */
+export declare class VcModel {
+  /** Build a [`JsVcModel`] backed by RVC. */
+  static rvc(options?: JsRvcOptions | undefined | null): VcModel
+  /**
+   * Backend identifier — same value `modelId` returns on the per-
+   * backend `#[napi]` class (e.g. `"rvc"`).
+   */
+  get modelId(): string
+  /**
+   * Convert a source utterance to the voice of a registered target
+   * speaker.
+   *
+   * # Errors
+   * See per-backend documentation
+   * ([`JsRvcBackend::convert_voice`]).
+   */
+  convertVoice(inputAudioPath: string, targetVoiceId: string): Promise<JsVcResult>
+  /**
+   * Stream voice conversion over an in-memory PCM buffer.
+   *
+   * # Errors
+   * See per-backend documentation
+   * ([`JsRvcBackend::stream_convert_pcm`]).
+   */
+  streamConvertPcm(inputSamples: Float32Array, targetVoiceId: string, onChunk: StreamVcChunkCallbackTsfn): Promise<void>
+  /**
+   * List the target voices the active backend can currently render.
+   *
+   * # Errors
+   * See per-backend documentation.
+   */
+  listTargetVoices(): Promise<Array<JsTargetVoice>>
+  /**
+   * Register a new target voice from a reference utterance.
+   *
+   * # Errors
+   * See per-backend documentation.
+   */
+  registerTargetVoice(voiceId: string, referenceAudioPath: string): Promise<void>
+}
+export type JsVcModel = VcModel
+
+/**
+ * r" Base class for voice-conversion providers.
+ * r"
+ * r" Mirrors the [`blazen_llm::providers::VcProvider`] capability trait —
+ * r" source utterance + target voice → re-voiced audio, plus voice
+ * r" cloning. Subclass and override `convertVoice()` (and optionally
+ * r" `cloneVoice()`, `listVoices()`, `deleteVoice()`).
+ */
+export declare class VcProvider {
+  constructor(config: CapabilityProviderConfig)
+  /** The provider identifier. */
+  get providerId(): string | null
+  /** The base URL, if set. */
+  get baseUrl(): string | null
+  /**
+   * Estimated memory footprint in bytes (host RAM if the
+   * provider targets the CPU, GPU VRAM otherwise), if set.
+   */
+  get memoryEstimateBytes(): number | null
+  /** r" Convert the source utterance into the target voice. */
+  convertVoice(request: any): Promise<any>
+  /** r" Clone a voice from reference audio clips. */
+  cloneVoice(request: any): Promise<any>
+  /** r" List all voices known to this provider. */
+  listVoices(): Promise<any>
+  /** r" Delete a previously-cloned voice. */
+  deleteVoice(voice: any): Promise<any>
+}
+export type JsVcProvider = VcProvider
+
 /**
  * r" Base class for video generation providers.
  * r"
@@ -5519,6 +6677,28 @@ export declare class Workflow {
    * awkward parallel-arrays signature into a single class instance.
    */
   addParallelSubworkflowsObj(step: ParallelSubWorkflowsStep): void
+  /**
+   * Register a sub-pipeline step that delegates to a `Pipeline`.
+   * Mirrors [`blazen_core::WorkflowBuilder::add_subpipeline_step`] and is
+   * the pipeline analogue of [`Self::add_subworkflow_step`].
+   *
+   * - `name`: human-readable step name.
+   * - `accepts`: array of event type strings this step handles.
+   * - `emits`: array of event type strings this step may emit (informational).
+   * - `inner`: the child `Pipeline` to run (cloned at registration time,
+   *   so it must not have been consumed by `start`/`run`/`resume`).
+   * - `timeoutSecs`: optional wall-clock timeout for the child run.
+   * - `retryConfig`: optional retry policy for the child run.
+   */
+  addSubpipelineStep(name: string, accepts: Array<string>, emits: Array<string>, inner: Pipeline, timeoutSecs?: number | undefined | null, retryConfig?: JsRetryConfig | undefined | null): void
+  /**
+   * Register a pre-built [`SubPipelineStep`] wrapper.
+   *
+   * Object-form of [`Self::add_subpipeline_step`]: the same step instance
+   * can be reused across multiple workflows since its inner child pipeline
+   * is captured in `Arc<dyn SubExecutable>` form at construction time.
+   */
+  addSubpipelineStepObj(step: SubPipelineStep): void
   /**
    * Add a step to the workflow.
    *
@@ -5527,7 +6707,7 @@ export declare class Workflow {
    * - `handler`: Async function `(event, ctx) => Event` that processes
    *   events and returns the next event.
    */
-  addStep(name: string, eventTypes: Array<string>, handler: StepHandlerTsfn): void
+  addStep(name: string, eventTypes: Array<string>, handler: (event: Event, ctx: Context) => Event | Event[] | null | void | Promise<Event | Event[] | null | void>): void
   /**
    * Set the workflow timeout in seconds.
    *
@@ -5549,7 +6729,7 @@ export declare class Workflow {
    *
    * Returns the final result when the workflow completes.
    */
-  runStreaming(input: any, onEvent: StreamCallbackTsfn): Promise<JsWorkflowResult>
+  runStreaming(input: any, onEvent: (event: Event) => void): Promise<JsWorkflowResult>
   /**
    * Run the workflow and return a handler object.
    *
@@ -5652,7 +6832,7 @@ export declare class WorkflowBuilder {
    * JavaScript function; the workflow engine routes events whose
    * `type` matches one of `eventTypes` to it.
    */
-  addStep(name: string, eventTypes: Array<string>, handler: StepHandlerTsfn): this
+  addStep(name: string, eventTypes: Array<string>, handler: (event: Event, ctx: Context) => Event | Event[] | null | void | Promise<Event | Event[] | null | void>): this
   /**
    * Set the workflow timeout in seconds. A non-positive value
    * disables the timeout (equivalent to [`Self::no_timeout`]).
@@ -5838,7 +7018,7 @@ export declare class WorkflowHandler {
    * are captured. Subsequent calls subscribe a fresh stream that
    * starts from the current point in time.
    */
-  streamEvents(onEvent: StreamCallbackTsfn): Promise<void>
+  streamEvents(onEvent: (event: Event) => void): Promise<void>
 }
 export type JsWorkflowHandler = WorkflowHandler
 
@@ -5937,16 +7117,36 @@ export declare class XaiProvider {
   /** Get the model ID. */
   get modelId(): string
   /** Perform a chat completion. */
-  complete(messages: Array<JsChatMessage>): Promise<JsCompletionResponse>
+  complete(messages: Array<JsChatMessage>): Promise<JsModelResponse>
   /** Perform a chat completion with additional options. */
-  completeWithOptions(messages: Array<JsChatMessage>, options: JsCompletionOptions): Promise<JsCompletionResponse>
+  completeWithOptions(messages: Array<JsChatMessage>, options: JsModelOptions): Promise<JsModelResponse>
   /** Stream a chat completion. */
   stream(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn): Promise<void>
   /** Stream a chat completion with additional options. */
-  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsCompletionOptions): Promise<void>
+  streamWithOptions(messages: Array<JsChatMessage>, onChunk: StreamChunkCallbackTsfn, options: JsModelOptions): Promise<void>
 }
 export type JsXaiProvider = XaiProvider
 
+/**
+ * Caller-supplied options when mounting a `LoRA` adapter via
+ * [`JsModelManager::load_adapter`].
+ *
+ * Mirrors [`blazen_llm::AdapterOptions`]; `scale` is optional and
+ * defaults to `1.0` (full strength, PEFT convention) when omitted.
+ */
+export interface AdapterOptions {
+  /**
+   * Caller-chosen identifier for this adapter mount. Must be unique
+   * per `(model, adapter)` pair within a manager.
+   */
+  adapterId: string
+  /**
+   * Scaling factor applied to the adapter's delta-weights. Defaults
+   * to `1.0` when not provided.
+   */
+  scale?: number
+}
+
 /**
  * Aggregate one [`JsUsageEvent`] into a [`crate::types::JsTokenUsageClass`].
  * Returns a fresh class instance that adds the seven token counters from the
@@ -6010,22 +7210,41 @@ export interface AgentConfig {
  *   `toolName`, `toolCallId`, and `arguments` are populated.
  * - `"toolResult"` -- a tool execution completed. `iteration`, `toolName`,
  *   and `result` are populated.
+ * - `"toolError"` -- a tool execution failed and the error was fed back to
+ *   the model as a `tool_result` so it can retry (the run is NOT aborted).
+ *   `iteration`, `toolName`, `result` (the `{"error": ...}` payload), and
+ *   `error` are populated.
  * - `"iterationComplete"` -- the model produced a response. `iteration`
  *   and `hadToolCalls` are populated.
  */
 export interface AgentEvent {
-  /** Discriminant: `"toolCalled"`, `"toolResult"`, or `"iterationComplete"`. */
+  /**
+   * Discriminant: `"toolCalled"`, `"toolResult"`, `"toolError"`, or
+   * `"iterationComplete"`.
+   */
   kind: string
   /** Iteration index (0-based). */
   iteration: number
-  /** Tool name. Populated for `"toolCalled"` and `"toolResult"`. */
+  /**
+   * Tool name. Populated for `"toolCalled"`, `"toolResult"`, and
+   * `"toolError"`.
+   */
   toolName?: string
   /** Tool call ID. Populated for `"toolCalled"`. */
   toolCallId?: string
   /** Tool arguments. Populated for `"toolCalled"`. */
   arguments?: any
-  /** Tool result payload. Populated for `"toolResult"`. */
+  /**
+   * Tool result payload. Populated for `"toolResult"`, and for
+   * `"toolError"` (where it holds the `{"error": ...}` payload sent to the
+   * model).
+   */
   result?: any
+  /**
+   * Error message. Populated only for `"toolError"` -- the failure that was
+   * fed back to the model as a `tool_result` so it could retry.
+   */
+  error?: string
   /**
    * Whether this iteration contained tool calls. Populated for
    * `"iterationComplete"`.
@@ -6039,6 +7258,35 @@ export declare function audioInput(name: string, description: string): any
 /** Build a JSON Schema declaring a single required CAD-file-handle input. */
 export declare function cadInput(name: string, description: string): any
 
+/**
+ * The capability a provider serves. Mirrors
+ * [`blazen_llm::providers::CapabilityKind`].
+ */
+export declare const enum CapabilityKind {
+  /** Large language model — chat / completion / streaming. */
+  Llm = 'Llm',
+  /** Text-to-speech audio synthesis. */
+  Tts = 'Tts',
+  /** Speech-to-text transcription. */
+  Stt = 'Stt',
+  /** Text-to-music / text-to-sfx audio generation. */
+  Music = 'Music',
+  /** Voice conversion. */
+  Vc = 'Vc',
+  /** 3D mesh generation. */
+  ThreeD = 'ThreeD',
+  /** 2D image generation. */
+  ImageGen = 'ImageGen',
+  /** Vector embedding generation. */
+  Embedding = 'Embedding',
+  /** Neural audio codec. */
+  Codec = 'Codec',
+  /** Background removal on existing images. */
+  BackgroundRemoval = 'BackgroundRemoval',
+  /** Video generation. */
+  Video = 'Video'
+}
+
 /** Configuration passed to any capability provider constructor. */
 export interface CapabilityProviderConfig {
   /** Short identifier for this provider (e.g. `"elevenlabs"`, `"fal"`). */
@@ -6090,9 +7338,9 @@ export interface CitationOptions {
  * order as the input.
  *
  * ```typescript
- * import { CompletionModel, ChatMessage, completeBatch } from 'blazen';
+ * import { Model, ChatMessage, completeBatch } from 'blazen';
  *
- * const model = CompletionModel.openai({ apiKey: "sk-..." });
+ * const model = Model.openai({ apiKey: "sk-..." });
  *
  * const result = await completeBatch(
  *   model,
@@ -6113,7 +7361,7 @@ export interface CitationOptions {
  * }
  * ```
  */
-export declare function completeBatch(model: JsCompletionModel, messageSets: Array<Array<JsChatMessage>>, options?: JsBatchOptions | undefined | null): Promise<BatchResult>
+export declare function completeBatch(model: JsModel, messageSets: Array<Array<JsChatMessage>>, options?: JsBatchOptions | undefined | null): Promise<BatchResult>
 
 /**
  * Run a batch using a typed [`JsBatchConfig`] instance instead of an options
@@ -6124,85 +7372,13 @@ export declare function completeBatch(model: JsCompletionModel, messageSets: Arr
  * multiple calls.
  *
  * ```typescript
- * import { CompletionModel, ChatMessage, BatchConfig, completeBatchConfig } from 'blazen';
+ * import { Model, ChatMessage, BatchConfig, completeBatchConfig } from 'blazen';
  *
  * const cfg = new BatchConfig(4);
  * const result = await completeBatchConfig(model, messageSets, cfg);
  * ```
  */
-export declare function completeBatchConfig(model: JsCompletionModel, messageSets: Array<Array<JsChatMessage>>, config: BatchConfig): Promise<BatchResult>
-
-/**
- * Configuration for subclassed `CompletionModel` instances.
- *
- * When extending `CompletionModel` from JavaScript/TypeScript, pass this
- * to `super()` so the base class can report `modelId` and other metadata
- * without a concrete provider.
- *
- * ```javascript
- * class MyLLM extends CompletionModel {
- *   constructor() {
- *     super({ modelId: "my-custom-model", contextLength: 8192 });
- *   }
- * }
- * ```
- */
-export interface CompletionModelConfig {
-  /** Model identifier (e.g. `"my-org/custom-llama"`). */
-  modelId?: string
-  /** Maximum context window in tokens. */
-  contextLength?: number
-  /** Base URL for HTTP-based providers. */
-  baseUrl?: string
-  /**
-   * Estimated memory footprint in bytes when loaded (host RAM if
-   * the provider targets the CPU, GPU VRAM otherwise).
-   */
-  memoryEstimateBytes?: number
-  /** Maximum output tokens the model supports. */
-  maxOutputTokens?: number
-}
-
-/**
- * Provider-agnostic request for a chat completion.
- *
- * Mirrors [`blazen_llm::CompletionRequest`]. Most callers reach for the
- * [`crate::providers::JsCompletionModel`] factory + per-call options
- * path; this typed shape exists for callers who need to build a request
- * envelope explicitly (e.g. forwarding the same request through multiple
- * middleware layers).
- */
-export interface CompletionRequest {
-  /**
-   * The conversation history as JSON-serialized `ChatMessage` values.
-   *
-   * Each entry must round-trip through `serde_json` into a Rust
-   * [`blazen_llm::ChatMessage`]. Use the `ChatMessage` class to build
-   * these in JS.
-   */
-  messages: Array<any>
-  /** Tools available for the model to invoke. */
-  tools?: Array<JsToolDefinition>
-  /** Sampling temperature. */
-  temperature?: number
-  /** Maximum number of tokens to generate. */
-  maxTokens?: number
-  /** Nucleus sampling parameter. */
-  topP?: number
-  /**
-   * JSON-encoded response format hint (raw, matching the `OpenAI` shape
-   * or the typed [`crate::types::JsResponseFormat`] when serialized).
-   */
-  responseFormat?: any
-  /** Override the provider's default model for this request. */
-  model?: string
-  /** Output modalities (e.g., `["text"]`, `["image", "text"]`). */
-  modalities?: Array<string>
-  /** Image generation configuration (model-specific). */
-  imageConfig?: any
-  /** Audio output configuration (voice, format, etc.). */
-  audioConfig?: any
-}
+export declare function completeBatchConfig(model: JsModel, messageSets: Array<Array<JsChatMessage>>, config: BatchConfig): Promise<BatchResult>
 
 /**
  * Compute the cost in USD for an audio call (TTS / STT) given the model id
@@ -6414,6 +7590,28 @@ export interface EventEnvelope {
  */
 export declare function extractInlineArtifacts(content: string): Array<JsArtifact>
 
+/**
+ * Configuration for the faster-whisper (`CTranslate2`) STT backend.
+ *
+ * Mirrors [`blazen_llm::FasterWhisperConfig`]. All fields are optional;
+ * unset fields fall back to the upstream defaults
+ * (`Systran/faster-whisper-tiny`, HF download on first use).
+ */
+export interface FasterWhisperConfig {
+  /** Hugging Face repo id for the `CTranslate2` Whisper bundle. */
+  modelId?: string
+  /**
+   * Local path to a pre-downloaded bundle directory. When unset, the
+   * bundle is fetched from Hugging Face on first transcription.
+   */
+  modelDir?: string
+  /**
+   * Optional Hugging Face Hub revision pin (branch, tag, or commit
+   * SHA).
+   */
+  revision?: string
+}
+
 /**
  * Fetch a single model's pricing from `DEFAULT_MODEL_PRICING_URL_BASE` using
  * the platform-default HTTP client and register it. Resolves to the registered
@@ -6678,6 +7876,41 @@ export declare const enum JoinStrategy {
   FirstCompletes = 'FirstCompletes'
 }
 
+/**
+ * Handle returned by [`JsModelManager::load_adapter`] and accepted by
+ * JS-side `unloadAdapter` lifecycle callbacks (see
+ * [`JsModelManager::register_local_model`]).
+ *
+ * Mirrors [`blazen_llm::AdapterHandle`]; `mountStrategy` is one of
+ * `"attached"`, `"rebuilt"`, or `"merged"`.
+ */
+export interface JsAdapterHandle {
+  /** Echoes [`AdapterOptions::adapter_id`]. */
+  adapterId: string
+  /** Bytes the adapter occupies on top of the base model. */
+  memoryBytes: bigint
+  /**
+   * One of `"attached"`, `"rebuilt"`, or `"merged"` — what the
+   * backend actually did to honor the mount request.
+   */
+  mountStrategy: string
+}
+
+/**
+ * Snapshot of one mounted adapter, returned by
+ * [`JsModelManager::list_adapters`]. Mirrors [`blazen_llm::AdapterStatus`].
+ */
+export interface JsAdapterStatus {
+  /** Caller-supplied adapter identifier. */
+  adapterId: string
+  /** Scaling factor applied at mount time. */
+  scale: number
+  /** Absolute filesystem path to the adapter directory. */
+  sourceDir: string
+  /** Bytes the adapter occupies on top of the base model. */
+  memoryBytes: bigint
+}
+
 /** An entry to add to the memory store (used by `addMany`). */
 export interface JsAddEntry {
   /** Unique identifier. If empty, one will be generated. */
@@ -6829,6 +8062,28 @@ export interface JsAudioContent {
   durationSeconds?: number
 }
 
+/**
+ * Construction-time options for [`JsAudioGenBackend`]. All fields
+ * optional — defaults match `facebook/audiogen-medium`.
+ */
+export interface JsAudioGenOptions {
+  /**
+   * Override the Hugging Face Hub repo id. Defaults to
+   * `"facebook/audiogen-medium"`.
+   */
+  repoId?: string
+  /** Optional pinned revision (commit SHA or tag) for the HF repo. */
+  revision?: string
+  /** Optional override for the Hugging Face cache directory. */
+  cacheDir?: string
+  /**
+   * Hard safety cap on the requested duration (seconds). Defaults to
+   * 30 s. AudioGen-medium's absolute upper bound is 30 s; requests past
+   * either limit surface `MusicInvalidInputError`.
+   */
+  maxDurationSeconds?: number
+}
+
 export interface JsAudioResult {
   audio: Array<JsGeneratedAudio>
   timing: JsRequestTiming
@@ -6857,6 +8112,26 @@ export interface JsAzureOptions {
   apiVersion?: string
 }
 
+/**
+ * Local-inference backend identifier returned by
+ * [`JsModelManager::load_from_hf`] and accepted as a forced override on
+ * [`JsHfLoadOptions::backend_hint`].
+ */
+export declare const enum JsBackendHint {
+  /**
+   * `mistral.rs` — broad architecture coverage, handles both safetensors
+   * and GGUF, supports vision/multimodal models.
+   */
+  mistralrs = 'mistralrs',
+  /**
+   * `candle` — pure-Rust, supports safetensors and GGUF for the subset of
+   * architectures candle ships.
+   */
+  candle = 'candle',
+  /** `llama.cpp` — GGUF only, best CPU performance and lowest memory. */
+  llamacpp = 'llamacpp'
+}
+
 export interface JsBackgroundRemovalRequest {
   imageUrl: string
   model?: string
@@ -6973,35 +8248,6 @@ export interface JsClientConnectOptions {
   mtls?: JsMtlsOptions
 }
 
-/** Options for a chat completion request. */
-export interface JsCompletionOptions {
-  temperature?: number
-  maxTokens?: number
-  topP?: number
-  model?: string
-  tools?: Array<JsToolDefinition>
-  /** JSON Schema for structured output / response format. */
-  responseFormat?: any
-}
-
-/** The result of a chat completion. */
-export interface JsCompletionResponse {
-  content?: string
-  toolCalls: Array<JsToolCall>
-  usage?: JsTokenUsage
-  model: string
-  finishReason?: string
-  cost?: number
-  timing?: JsRequestTiming
-  images: Array<JsGeneratedImage>
-  audio: Array<JsGeneratedAudio>
-  videos: Array<JsGeneratedVideo>
-  reasoning?: JsReasoningTrace
-  citations: Array<JsCitation>
-  artifacts: Array<JsArtifact>
-  metadata: any
-}
-
 export interface JsComputeRequest {
   model: string
   input: any
@@ -7082,7 +8328,7 @@ export interface JsContentPart {
   image?: JsImageContent
   audio?: JsAudioContent
   video?: JsVideoContent
-  file?: FileContent
+  file?: JsFileContent
 }
 
 /** Request to dereference a remote session ref. */
@@ -7151,6 +8397,43 @@ export declare const enum JsDiffusionScheduler {
   Ddim = 'ddim'
 }
 
+/**
+ * Configuration for distributed (ring-AllReduce) training. Pass to
+ * the training verbs to enable gradient averaging across
+ * `worldSize` workers connected via gRPC. Each worker holds an
+ * identical-shape gradient tensor; the ring algorithm sums and
+ * averages per-parameter gradients before the optimizer step.
+ *
+ * `rank` is the 0-indexed rank of this worker; `worldSize` is the
+ * total number of workers. `peers` is the ordered list of
+ * `"host:port"` gRPC endpoints — one entry per rank. `masterAddr`
+ * + `masterPort` identify the bootstrap node (typically the host
+ * part of `peers[0]`).
+ */
+export interface JsDistributedConfig {
+  rank: number
+  worldSize: number
+  peers: Array<string>
+  masterAddr: string
+  masterPort: number
+}
+
+/** Direct Preference Optimization (DPO) configuration. */
+export interface JsDpoConfig {
+  /** Shared training hyperparameters. */
+  core: JsTrainCoreConfig
+  /** LoRA hyperparameters applied to the policy model. */
+  lora?: JsLoraConfig
+  /** KL-regularization strength. Default `0.1`. */
+  beta?: number
+  /** Conservative DPO label smoothing (cDPO). Default `0.0`. */
+  labelSmoothing?: number
+  /** Reference model repo. `null` reuses `core.baseModelRepo`. */
+  referenceModelRepo?: string
+  /** Optional revision for the reference model. */
+  referenceModelRevision?: string
+}
+
 /** The result of an embedding operation. */
 export interface JsEmbeddingResponse {
   /** The embedding vectors (one per input text). */
@@ -7277,6 +8560,30 @@ export interface JsFinishReason {
   value: string
 }
 
+/**
+ * Full fine-tune configuration (every parameter trains; no LoRA adapter).
+ *
+ * `gradientCheckpointing = true` is accepted for forward compatibility
+ * but the trainer currently rejects it at init time because candle
+ * 0.10.2 has no activation-checkpointing primitive.
+ */
+export interface JsFullFineTuneConfig {
+  /** Shared training hyperparameters. */
+  core: JsTrainCoreConfig
+  /** Activation checkpointing (currently unsupported in the trainer). */
+  gradientCheckpointing?: boolean
+}
+
+/** Result of a completed full fine-tune run. */
+export interface JsFullFineTuneResult {
+  /** Directory the trained model weights were written to. */
+  outputDir: string
+  /** Final training loss. */
+  finalLoss: number
+  /** Total optimizer steps executed. */
+  stepsCompleted: number
+}
+
 export interface JsGenerated3DModel {
   media: JsMediaOutput
   vertexCount?: number
@@ -7306,6 +8613,42 @@ export interface JsGeneratedVideo {
   fps?: number
 }
 
+/**
+ * Caller-supplied options for [`JsModelManager::load_from_hf`].
+ *
+ * Mirrors [`blazen_manager::HfLoadOptions`]; every field is optional.
+ */
+export interface JsHfLoadOptions {
+  /**
+   * Force a specific backend; skips engine inference but still probes
+   * the repo for memory sizing.
+   */
+  backendHint?: JsBackendHint
+  /**
+   * Git revision (branch, tag, or commit sha). Defaults to the repo's
+   * default branch.
+   */
+  revision?: string
+  /**
+   * Hugging Face access token. When omitted, falls back to the
+   * `HF_TOKEN` environment variable, then to anonymous access.
+   */
+  hfToken?: string
+  /** Override the on-disk cache directory used by `hf-hub`. */
+  cacheDir?: string
+  /**
+   * Device specifier forwarded to the chosen provider (`"cpu"`,
+   * `"cuda:0"`, `"metal"`, …).
+   */
+  device?: string
+  /** Explicit GGUF filename for repos that ship multiple quantizations. */
+  ggufFile?: string
+  /** Override the auto-derived memory estimate, in bytes. */
+  memoryEstimateBytes?: bigint
+  /** Pool label (`"cpu"`, `"gpu"`, `"gpu:N"`). Defaults to `"cpu"`. */
+  pool?: string
+}
+
 /** An outgoing HTTP request, as seen by a JavaScript [`HttpClient`] subclass. */
 export interface JsHttpRequest {
   /** HTTP method (`"GET"`, `"POST"`, `"PUT"`, `"DELETE"`, `"PATCH"`). */
@@ -7408,6 +8751,39 @@ export declare const enum JsJobStatus {
   Cancelled = 'cancelled'
 }
 
+/** Optional knobs for [`JsJsonlDataset::from_path`]. */
+export interface JsJsonlDatasetOptions {
+  /**
+   * Jinja2 chat template (from `tokenizer_config.json`). Required when
+   * rows use the `messages` shape.
+   */
+  chatTemplate?: string
+  /** Maximum tokenized sequence length per example. Default `2048`. */
+  maxSeqLen?: number
+  /** Candle device string. Default `"cpu"`. */
+  device?: string
+  /** Token id to write into padded positions. Default `0`. */
+  padTokenId?: number
+}
+
+/** Kahneman-Tversky Optimization (KTO) configuration. */
+export interface JsKtoConfig {
+  /** Shared training hyperparameters. */
+  core: JsTrainCoreConfig
+  /** LoRA hyperparameters applied to the policy model. */
+  lora?: JsLoraConfig
+  /** KL-regularization strength. Default `0.1`. */
+  beta?: number
+  /** Loss weight applied to desirable examples. Default `1.0`. */
+  lambdaD?: number
+  /** Loss weight applied to undesirable examples. Default `1.0`. */
+  lambdaU?: number
+  /** Reference model repo. `null` reuses `core.baseModelRepo`. */
+  referenceModelRepo?: string
+  /** Optional revision for the reference model. */
+  referenceModelRevision?: string
+}
+
 /**
  * Options for the local llama.cpp LLM backend.
  *
@@ -7436,6 +8812,21 @@ export interface JsLlamaCppOptions {
   cacheDir?: string
 }
 
+/** LoRA hyperparameters. */
+export interface JsLoraConfig {
+  /** Low-rank dimension (PEFT "r"). Default `16`. */
+  rank?: number
+  /** Scaling numerator; effective per-layer scale is `alpha / rank`. Default `32`. */
+  alpha?: number
+  /** Dropout applied to LoRA-A input. Default `0.0`. */
+  dropout?: number
+  /**
+   * Module-name suffixes to inject LoRA into. Default
+   * `["q_proj","k_proj","v_proj","o_proj"]`.
+   */
+  targetModules?: Array<string>
+}
+
 export interface JsMediaOutput {
   url?: string
   base64?: string
@@ -7483,7 +8874,7 @@ export interface JsMiddlewareConfig {
  * All other fields are optional.
  *
  * ```javascript
- * const model = CompletionModel.mistralrs({
+ * const model = Model.mistralrs({
  *   modelId: "mistralai/Mistral-7B-Instruct-v0.3",
  *   device: "cuda:0",
  *   quantization: "q4_k_m",
@@ -7507,6 +8898,42 @@ export interface JsMistralRsOptions {
   cacheDir?: string
 }
 
+/** Mixed-precision mode passed to [`JsTrainConfig`]. */
+export declare const enum JsMixedPrecision {
+  None = 'none',
+  Bf16 = 'bf16'
+}
+
+/** TLS options accepted by [`JsModelClient::connect_with_tls`]. */
+export interface JsModelClientTlsOptions {
+  /**
+   * Filesystem path to the PEM-encoded CA certificate used to verify
+   * the server.
+   */
+  caCert: string
+  /**
+   * Optional path to the PEM-encoded client certificate (mTLS). Must
+   * be paired with [`Self::client_key`].
+   */
+  clientCert?: string
+  /**
+   * Optional path to the PEM-encoded client private key (mTLS). Must
+   * be paired with [`Self::client_cert`].
+   */
+  clientKey?: string
+}
+
+/** Options for a chat completion request. */
+export interface JsModelOptions {
+  temperature?: number
+  maxTokens?: number
+  topP?: number
+  model?: string
+  tools?: Array<JsToolDefinition>
+  /** JSON Schema for structured output / response format. */
+  responseFormat?: any
+}
+
 /**
  * Pricing information for a model in USD per million tokens.
  *
@@ -7524,6 +8951,24 @@ export interface JsModelPricing {
   perSecond?: number
 }
 
+/** The result of a chat completion. */
+export interface JsModelResponse {
+  content?: string
+  toolCalls: Array<JsToolCall>
+  usage?: JsTokenUsage
+  model: string
+  finishReason?: string
+  cost?: number
+  timing?: JsRequestTiming
+  images: Array<JsGeneratedImage>
+  audio: Array<JsGeneratedAudio>
+  videos: Array<JsGeneratedVideo>
+  reasoning?: JsReasoningTrace
+  citations: Array<JsCitation>
+  artifacts: Array<JsArtifact>
+  metadata: any
+}
+
 /** Status snapshot for a single registered model. */
 export interface JsModelStatus {
   /** Model identifier. */
@@ -7540,16 +8985,69 @@ export interface JsModelStatus {
 }
 
 /**
- * PEM file paths for mTLS configuration. Used by
- * [`crate::controlplane::client::JsControlPlaneClient::connect`].
+ * PEM file paths for mTLS configuration. Used by
+ * [`crate::controlplane::client::JsControlPlaneClient::connect`].
+ */
+export interface JsMtlsOptions {
+  /** Path to the client certificate PEM file. */
+  cert: string
+  /** Path to the client private-key PEM file. */
+  key: string
+  /** Path to the CA PEM file used to authenticate the server. */
+  ca: string
+}
+
+/**
+ * One emission from a streaming music backend.
+ *
+ * Carries a `Float32Array` slice of 32-bit float PCM samples in `[-1, 1]`
+ * at the backend's native output sample rate (32 kHz for MusicGen,
+ * 16 kHz for AudioGen, 44.1 kHz stereo for Stable Audio), an `isFinal`
+ * flag, and an optional measured per-chunk latency in seconds.
+ */
+export interface JsMusicChunk {
+  /**
+   * 32-bit float PCM samples in `[-1, 1]` at the backend's native
+   * output sample rate (interleaved for multi-channel outputs).
+   */
+  samples: Float32Array
+  /**
+   * `true` when this is the final chunk emitted for the generation
+   * call; `false` for intermediate chunks.
+   */
+  isFinal: boolean
+  /**
+   * Optional measured latency-from-call-start for this chunk, in
+   * seconds. `null` when the backend does not surface a timestamp.
+   */
+  latencySeconds?: number
+}
+
+/**
+ * Construction-time options for [`JsMusicgenBackend`]. All fields
+ * optional — defaults match the small CPU-friendly variant.
  */
-export interface JsMtlsOptions {
-  /** Path to the client certificate PEM file. */
-  cert: string
-  /** Path to the client private-key PEM file. */
-  key: string
-  /** Path to the CA PEM file used to authenticate the server. */
-  ca: string
+export interface JsMusicgenOptions {
+  /** Which checkpoint to load. Defaults to `"small"`. */
+  variant?: JsMusicgenVariant
+  /** Optional override for the Hugging Face cache directory. */
+  cacheDir?: string
+  /**
+   * Hard safety cap on the requested duration (seconds). Defaults to
+   * 30 s. The absolute upper bound enforced by MusicGen itself is
+   * 60 s — requests past either limit surface `MusicInvalidInputError`.
+   */
+  maxDurationSeconds?: number
+}
+
+/** Available MusicGen checkpoints on Hugging Face Hub. */
+export declare const enum JsMusicgenVariant {
+  /** `facebook/musicgen-small` -- ~300M params, 32 kHz mono. */
+  Small = 'small',
+  /** `facebook/musicgen-medium` -- ~1.5B params, 32 kHz mono. */
+  Medium = 'medium',
+  /** `facebook/musicgen-large` -- ~3.3B params, 32 kHz mono. */
+  Large = 'large'
 }
 
 export interface JsMusicRequest {
@@ -7559,6 +9057,33 @@ export interface JsMusicRequest {
   parameters?: any
 }
 
+/**
+ * Fully-rendered music + SFX result returned by the non-streaming
+ * `generateMusic` / `generateSfx` entry points.
+ *
+ * `bytes` carries the encoded clip — typically a WAV container holding
+ * PCM samples; `format` distinguishes the container so callers can route
+ * directly to a player without re-sniffing the payload.
+ */
+export interface JsMusicResult {
+  /**
+   * Encoded audio bytes (typically WAV for MusicGen / AudioGen /
+   * Stable Audio).
+   */
+  bytes: Uint8Array
+  /**
+   * Container format: one of `"wav"`, `"mp3"`, `"flac"`, `"opus"`,
+   * or `"pcm"`.
+   */
+  format: string
+  /** Sample rate in hertz. */
+  sampleRate: number
+  /** Channel count (mono = 1, stereo = 2). */
+  channels: number
+  /** Duration of the clip in seconds, if known. */
+  durationSeconds?: number
+}
+
 /**
  * Configuration for an OpenAI-compatible provider.
  *
@@ -7594,6 +9119,32 @@ export interface JsOpenAiCompatConfig {
   supportsModelListing?: boolean
 }
 
+/** AdamW optimizer hyperparameters. */
+export interface JsOptimConfig {
+  /** Peak learning rate (applied at end of warmup). Default `2e-4`. */
+  learningRate?: number
+  /** AdamW beta1. Default `0.9`. */
+  beta1?: number
+  /** AdamW beta2. Default `0.999`. */
+  beta2?: number
+  /** AdamW numerical-stability epsilon. Default `1e-8`. */
+  epsilon?: number
+  /** Decoupled weight decay. Default `0.0`. */
+  weightDecay?: number
+  /** Global gradient L2-norm clip; `null` disables clipping. Default `1.0`. */
+  gradientClip?: number
+}
+
+/** Odds Ratio Preference Optimization (ORPO) configuration. */
+export interface JsOrpoConfig {
+  /** Shared training hyperparameters. */
+  core: JsTrainCoreConfig
+  /** LoRA hyperparameters. */
+  lora?: JsLoraConfig
+  /** Weight of the odds-ratio term relative to the SFT term. Default `0.1`. */
+  lambda?: number
+}
+
 /**
  * Metadata describing a remote session ref handed back by an
  * `invokeSubWorkflow` call.
@@ -7610,31 +9161,6 @@ export interface JsPeerRemoteRefDescriptor {
   createdAtEpochMs: number
 }
 
-/**
- * Options for the local Piper TTS backend.
- *
- * All fields are optional. `modelId` selects the voice (e.g.
- * `"en_US-amy-medium"`); when `null`, callers must set it before
- * synthesis can run.
- *
- * ```javascript
- * const provider = PiperProvider.create({
- *   modelId: "en_US-amy-medium",
- *   sampleRate: 22050,
- * });
- * ```
- */
-export interface JsPiperOptions {
-  /** Piper voice model identifier. */
-  modelId?: string
-  /** Speaker ID for multi-speaker models. */
-  speakerId?: number
-  /** Output audio sample rate in Hz. */
-  sampleRate?: number
-  /** Path to cache downloaded voice models. */
-  cacheDir?: string
-}
-
 /** Reported per-pool budget pair returned by [`JsModelManager::pools`]. */
 export interface JsPoolBudget {
   /** Pool label (`"cpu"` or `"gpu:N"`). */
@@ -7826,6 +9352,57 @@ export declare const enum JsRunStatus {
   Cancelled = 'Cancelled'
 }
 
+/**
+ * Construction-time options for [`JsRvcBackend`]. All fields optional
+ * — defaults match the upstream RVC reference (top-k = 8, blend = 0.75,
+ * V2 content encoder).
+ */
+export interface JsRvcOptions {
+  /**
+   * kNN neighbour count for the retrieval blend (`top_k`). Defaults
+   * to 8. Clamped to `>= 1` at query time.
+   */
+  topK?: number
+  /**
+   * Retrieval blend factor (`index_rate` in the upstream
+   * reference). Defaults to 0.75. Clamped into `[0.0, 1.0]`.
+   */
+  retrievalBlend?: number
+  /**
+   * Which ContentVec family to use for the shared HuBERT encoder.
+   * One of `"v1"` or `"v2"` (case-insensitive). Defaults to `"v2"`
+   * — the family contemporary RVC checkpoints target.
+   */
+  rvcVersion?: string
+}
+
+/** Learning-rate scheduler configuration. */
+export interface JsSchedulerConfig {
+  /** Schedule shape. Default `Cosine`. */
+  kind?: JsSchedulerKind
+  /** Linear-warmup duration in steps applied before the main shape. Default `0`. */
+  warmupSteps?: number
+}
+
+/** Learning-rate schedule shape passed to [`JsSchedulerConfig`]. */
+export declare const enum JsSchedulerKind {
+  Constant = 'constant',
+  Linear = 'linear',
+  Cosine = 'cosine'
+}
+
+/** Simple Preference Optimization (`SimPO`) configuration. */
+export interface JsSimpoConfig {
+  /** Shared training hyperparameters. */
+  core: JsTrainCoreConfig
+  /** LoRA hyperparameters. */
+  lora?: JsLoraConfig
+  /** Logit scaling for the length-normalized preference margin. Default `2.0`. */
+  beta?: number
+  /** Target reward margin between chosen and rejected. Default `1.0`. */
+  gamma?: number
+}
+
 export interface JsSpeechRequest {
   text: string
   voice?: string
@@ -7836,6 +9413,46 @@ export interface JsSpeechRequest {
   parameters?: any
 }
 
+/**
+ * Construction-time options for [`JsStableAudioBackend`]. All fields
+ * optional — defaults to the Small variant on CPU with F32 precision.
+ */
+export interface JsStableAudioOptions {
+  /** Which variant to load. Defaults to `"small"`. */
+  variant?: JsStableAudioVariant
+  /**
+   * Override the Hugging Face Hub repo id. Defaults to the variant's
+   * canonical repo (`stabilityai/stable-audio-open-{small,1.0}`).
+   */
+  hfRepo?: string
+  /**
+   * Path to a local `tokenizer.json` for the T5 conditioner. Required
+   * when the `audio-music-stable-audio` feature is enabled; ignored in
+   * stub mode.
+   */
+  tokenizerPath?: string
+  /**
+   * Optional override for a pre-downloaded safetensors weights file.
+   * When `None`, weights are pulled from the configured HF repo on
+   * first generation.
+   */
+  localWeightsPath?: string
+}
+
+/** Hyperparameter pack describing which Stable Audio Open checkpoint to load. */
+export declare const enum JsStableAudioVariant {
+  /**
+   * `stabilityai/stable-audio-open-small` -- 341 M params, 8-step
+   * distilled sampler, 11 s output cap.
+   */
+  Small = 'small',
+  /**
+   * `stabilityai/stable-audio-open-1.0` -- 1.21 B params, 100-step
+   * DPM-Solver++, 47 s output cap.
+   */
+  Open10 = 'open1_0'
+}
+
 /**
  * A persisted memory entry as returned from the underlying backend.
  *
@@ -7985,6 +9602,26 @@ export interface JsSubWorkflowResponse {
   error?: string
 }
 
+/**
+ * A registered target voice descriptor.
+ *
+ * Returned by [`crate::vc::JsRvcBackend::list_target_voices`] /
+ * [`crate::vc::JsVcModel::list_target_voices`] and accepted by the
+ * matching `convertVoice` / `streamConvertPcm` calls (the `id` field
+ * is the lookup key).
+ */
+export interface JsTargetVoice {
+  /**
+   * Backend-scoped identifier for this voice. Passed to
+   * `convertVoice` / `streamConvertPcm`.
+   */
+  id: string
+  /** Optional human-readable display name for UIs. */
+  label?: string
+  /** Native sample rate the backend renders this voice at, in Hz. */
+  sampleRateHz: number
+}
+
 export interface JsThreeDRequest {
   prompt?: string
   imageUrl?: string
@@ -8082,6 +9719,101 @@ export interface JsTractResponse {
   model: string
 }
 
+/** Full configuration for one training run. */
+export interface JsTrainConfig {
+  /** HuggingFace repo id of the base model. */
+  baseModelRepo: string
+  /** Filesystem directory where the trained adapter and checkpoints land. */
+  outputDir: string
+  lora?: JsLoraConfig
+  optim?: JsOptimConfig
+  scheduler?: JsSchedulerConfig
+  /** Total optimizer steps to run. Default `1000`. */
+  maxSteps?: number
+  /** Micro-batch size (per forward pass). Default `4`. */
+  batchSize?: number
+  /** Micro-batches accumulated before each optimizer step. Default `1`. */
+  gradientAccumulationSteps?: number
+  /** Maximum tokenized sequence length per example. Default `2048`. */
+  maxSeqLen?: number
+  /** Run evaluation every N steps when set. */
+  evalSteps?: number
+  /** Write a checkpoint every N steps when set. */
+  saveSteps?: number
+  /** RNG seed (dataset shuffling + LoRA `A` init). Default `42`. */
+  seed?: bigint
+  /** Mixed-precision mode for forward / backward. Default `Bf16`. */
+  mixedPrecision?: JsMixedPrecision
+  /** Device string forwarded to the trainer (`"cpu"`, `"cuda:0"`, `"metal"`). */
+  device?: string
+}
+
+/**
+ * Shared training hyperparameters for DPO/ORPO/SimPO/KTO and full
+ * fine-tune. Mirrors [`blazen_train::TrainCoreConfig`].
+ */
+export interface JsTrainCoreConfig {
+  /** HuggingFace repo id of the base model. */
+  baseModelRepo: string
+  /** Optional revision (branch / tag / commit) for the base model. */
+  baseModelRevision?: string
+  /** Filesystem directory for trained weights and checkpoints. */
+  outputDir: string
+  /** Total optimizer steps to run. Default `1000`. */
+  maxSteps?: number
+  /** Micro-batch size (per forward pass). Default `1`. */
+  batchSize?: number
+  /** Micro-batches accumulated before each optimizer step. Default `8`. */
+  gradientAccumulationSteps?: number
+  /** Maximum tokenized sequence length per example. Default `1024`. */
+  maxSeqLen?: number
+  /** Run evaluation every N steps when set. */
+  evalSteps?: number
+  /** Write a checkpoint every N steps when set. */
+  saveSteps?: number
+  /** RNG seed. Default `42`. */
+  seed?: bigint
+  /** Mixed-precision mode for forward / backward. Default `Bf16`. */
+  mixedPrecision?: JsMixedPrecision
+  /** Device string forwarded to the trainer (`"cpu"`, `"cuda:0"`, `"metal"`). */
+  device?: string
+  /** Optimizer hyperparameters (AdamW). */
+  optim?: JsOptimConfig
+  /** Learning-rate schedule. */
+  scheduler?: JsSchedulerConfig
+}
+
+/** Result of a completed training run. */
+export interface JsTrainedAdapter {
+  /** Directory the PEFT-format adapter was written to. */
+  adapterDir: string
+  /** Final training loss. */
+  finalLoss: number
+  /** Total optimizer steps executed. */
+  totalSteps: bigint
+}
+
+/**
+ * One observable event emitted during a training run.
+ *
+ * Switch on `kind` (`"started"` / `"stepCompleted"` / `"evaluating"` /
+ * `"evalCompleted"` / `"checkpointSaved"` / `"finished"`); other fields
+ * carry the per-variant payload and are absent for variants that do not
+ * populate them.
+ */
+export interface JsTrainingEvent {
+  kind: string
+  step?: bigint
+  loss?: number
+  learningRate?: number
+  elapsedMs?: number
+  totalSteps?: bigint
+  evalLoss?: number
+  checkpointPath?: string
+  adapterDir?: string
+  finalLoss?: number
+}
+
 export interface JsTranscriptionRequest {
   audioUrl: string
   language?: string
@@ -8108,6 +9840,45 @@ export interface JsTranscriptionSegment {
   speaker?: string
 }
 
+/**
+ * Which underlying TTS model to load. Maps onto
+ * [`blazen_llm::TtsModel`].
+ */
+export declare const enum JsTtsModel {
+  /** Kokoro-82M (default; small, CPU-friendly). */
+  Kokoro82m = 'Kokoro82m',
+  /** VibeVoice-1.5B (Microsoft). */
+  VibeVoice = 'VibeVoice',
+  /** Qwen3-TTS-12Hz-1.7B (`CustomVoice` variant). */
+  Qwen3Tts = 'Qwen3Tts'
+}
+
+/**
+ * Options for the local TTS backend.
+ *
+ * All fields are optional. `model` selects the backend (defaults to
+ * Kokoro-82M); `voice` selects the speaker preset.
+ *
+ * ```javascript
+ * const provider = TtsProvider.create({
+ *   model: "kokoro82m",
+ *   voice: "af_bella",
+ * });
+ * ```
+ */
+export interface JsTtsOptions {
+  /** TTS model to load. Defaults to `"kokoro82m"`. */
+  model?: JsTtsModel
+  /** Voice / speaker preset name. */
+  voice?: string
+  /** Language ISO 639-1 code (e.g. `"en"`, `"ja"`). */
+  language?: string
+  /** Output audio sample rate in Hz. */
+  sampleRate?: number
+  /** Path to cache downloaded model weights. */
+  cacheDir?: string
+}
+
 export interface JsUpscaleRequest {
   imageUrl: string
   scale: number
@@ -8115,6 +9886,56 @@ export interface JsUpscaleRequest {
   parameters?: any
 }
 
+/**
+ * One emission from a streaming voice-conversion backend.
+ *
+ * Carries a `Float32Array` slice of 32-bit float PCM samples in `[-1, 1]`
+ * at the target voice's native sample rate (typically 32 kHz or 40 kHz
+ * for RVC-family backends), an `isFinal` flag, and an optional measured
+ * per-chunk latency in seconds.
+ */
+export interface JsVcChunk {
+  /**
+   * 32-bit float PCM samples in `[-1, 1]` at the target voice's
+   * native sample rate (mono).
+   */
+  samples: Float32Array
+  /**
+   * `true` when this is the final chunk emitted for the conversion
+   * call; `false` for intermediate chunks.
+   */
+  isFinal: boolean
+  /**
+   * Optional measured latency-from-call-start for this chunk, in
+   * seconds. `null` when the backend does not surface a timestamp
+   * (RVC backends today do not).
+   */
+  latencySeconds?: number
+}
+
+/**
+ * Fully-rendered voice-conversion result returned by the non-streaming
+ * `convertVoice` entry point.
+ *
+ * `bytes` carries a self-describing WAV (RIFF/`fmt `/`data`) container
+ * holding 16-bit signed little-endian PCM samples at the target voice's
+ * native sample rate. `sampleRate` and `durationSeconds` are parsed out
+ * of the WAV header so callers don't need to re-sniff the payload to
+ * route it to a player.
+ */
+export interface JsVcResult {
+  /** Encoded WAV bytes (16-bit signed little-endian PCM). */
+  bytes: Uint8Array
+  /** Sample rate in hertz, parsed from the WAV `fmt ` chunk. */
+  sampleRate: number
+  /**
+   * Duration of the clip in seconds, derived from the WAV `data`
+   * chunk size + frame stride. `null` if the WAV header could not be
+   * parsed (in which case `sampleRate` falls back to `0`).
+   */
+  durationSeconds?: number
+}
+
 /** Video content for multimodal messages. */
 export interface JsVideoContent {
   source: JsImageSource
@@ -8367,6 +10188,20 @@ export declare function lookupPricing(modelId: string): JsModelPricing | null
 /** `true` when a step builder is registered under `stepId`. */
 export declare function lookupStepBuilder(stepId: string): boolean
 
+/**
+ * The decision returned by a loop stage's `until` predicate after each round.
+ *
+ * - `Continue`: run the inner stage again (subject to the `maxIterations`
+ *   cap).
+ * - `Done`: stop looping cleanly; the loop stage succeeds.
+ * - `Abort`: stop looping with an error.
+ */
+export declare const enum LoopDecision {
+  Continue = 'Continue',
+  Done = 'Done',
+  Abort = 'Abort'
+}
+
 /**
  * Tagged-union mirror of [`blazen_llm::types::MessageContent`].
  *
@@ -8440,6 +10275,37 @@ export interface ModelCapabilities {
   threeDGeneration: boolean
 }
 
+/**
+ * Configuration for subclassed `Model` instances.
+ *
+ * When extending `Model` from JavaScript/TypeScript, pass this
+ * to `super()` so the base class can report `modelId` and other metadata
+ * without a concrete provider.
+ *
+ * ```javascript
+ * class MyLLM extends Model {
+ *   constructor() {
+ *     super({ modelId: "my-custom-model", contextLength: 8192 });
+ *   }
+ * }
+ * ```
+ */
+export interface ModelConfig {
+  /** Model identifier (e.g. `"my-org/custom-llama"`). */
+  modelId?: string
+  /** Maximum context window in tokens. */
+  contextLength?: number
+  /** Base URL for HTTP-based providers. */
+  baseUrl?: string
+  /**
+   * Estimated memory footprint in bytes when loaded (host RAM if
+   * the provider targets the CPU, GPU VRAM otherwise).
+   */
+  memoryEstimateBytes?: number
+  /** Maximum output tokens the model supports. */
+  maxOutputTokens?: number
+}
+
 /**
  * Information about a model offered by a provider.
  *
@@ -8481,6 +10347,47 @@ export interface ModelManagerConfig {
   poolBudgets?: Record<string, bigint>
 }
 
+/**
+ * Provider-agnostic request for a chat completion.
+ *
+ * Mirrors [`blazen_llm::ModelRequest`]. Most callers reach for the
+ * [`crate::providers::JsModel`] factory + per-call options
+ * path; this typed shape exists for callers who need to build a request
+ * envelope explicitly (e.g. forwarding the same request through multiple
+ * middleware layers).
+ */
+export interface ModelRequest {
+  /**
+   * The conversation history as JSON-serialized `ChatMessage` values.
+   *
+   * Each entry must round-trip through `serde_json` into a Rust
+   * [`blazen_llm::ChatMessage`]. Use the `ChatMessage` class to build
+   * these in JS.
+   */
+  messages: Array<any>
+  /** Tools available for the model to invoke. */
+  tools?: Array<JsToolDefinition>
+  /** Sampling temperature. */
+  temperature?: number
+  /** Maximum number of tokens to generate. */
+  maxTokens?: number
+  /** Nucleus sampling parameter. */
+  topP?: number
+  /**
+   * JSON-encoded response format hint (raw, matching the `OpenAI` shape
+   * or the typed [`crate::types::JsResponseFormat`] when serialized).
+   */
+  responseFormat?: any
+  /** Override the provider's default model for this request. */
+  model?: string
+  /** Output modalities (e.g., `["text"]`, `["image", "text"]`). */
+  modalities?: Array<string>
+  /** Image generation configuration (model-specific). */
+  imageConfig?: any
+  /** Audio output configuration (voice, format, etc.). */
+  audioConfig?: any
+}
+
 /** Build an empty [`JsRetryStack`] with every scope set to `null`. */
 export declare function newRetryStack(): RetryStack
 
@@ -8496,30 +10403,48 @@ export declare function newUsageEvent(provider: string, model: string, runId: st
  *
  * ```javascript
  * initOtlp({
- *   endpoint: "http://localhost:4317",
+ *   endpoint: "https://otel.example.com/v1/traces",
  *   serviceName: "my-service",
- *   serviceVersion: "1.0.0",
- *   headers: { "x-api-key": "secret" },
+ *   protocol: "HttpProto",
+ *   headers: { Authorization: "Bearer xxx" },
  * });
  * ```
  */
 export interface OtlpConfig {
-  /** The OTLP endpoint URL (e.g. `"http://localhost:4317"`). */
+  /**
+   * The OTLP endpoint URL.
+   *
+   * For gRPC: `"http://localhost:4317"`.
+   * For HTTP: `"https://collector/v1/traces"`.
+   */
   endpoint: string
   /** The service name reported to the backend. */
   serviceName: string
+  /** Wire-level transport. Defaults to `HttpProto`. */
+  protocol?: OtlpProtocol
   /**
-   * Service version reported to the backend (recorded for forward
-   * compatibility; not yet forwarded by the underlying exporter).
+   * Service version (recorded for forward compatibility; not yet attached
+   * as a resource attribute by the underlying exporter).
    */
   serviceVersion?: string
   /**
-   * Additional headers to attach to OTLP requests (recorded for forward
-   * compatibility; not yet forwarded by the underlying exporter).
+   * Auth / routing headers attached to OTLP requests. Honored on HTTP;
+   * dropped with a warning on gRPC.
    */
   headers?: Record<string, string>
 }
 
+/** OTLP wire-level transport. */
+export declare const enum OtlpProtocol {
+  /** gRPC over tonic. Requires the `otlp` Cargo feature. */
+  Grpc = 'Grpc',
+  /**
+   * HTTP with binary protobuf payload. Requires the `otlp-http` Cargo
+   * feature.
+   */
+  HttpProto = 'HttpProto'
+}
+
 /**
  * Why a workflow was paused.
  *
@@ -8706,6 +10631,27 @@ export declare const enum ProviderId {
   Fal = 'fal'
 }
 
+/**
+ * Static metadata describing a provider instance. Mirrors
+ * [`blazen_llm::providers::ProviderMetadata`].
+ */
+export interface ProviderMetadata {
+  /**
+   * Canonical provider identifier — stable across binding surfaces
+   * (e.g. `"openai"`, `"fal"`, `"spark-tts"`).
+   */
+  providerId: string
+  /** What this provider does. */
+  capability: CapabilityKind
+  /**
+   * Optional human-readable name shown in UIs / logs. Defaults to
+   * `providerId` when unset.
+   */
+  displayName?: string
+  /** Optional version pin — typically the model id / weights revision. */
+  version?: string
+}
+
 /**
  * Optional hints attached to a `put` call.
  *
@@ -8828,6 +10774,17 @@ export declare function registerEventDeserializer(name: string, deserializer: De
  */
 export declare function registerFromModelInfo(info: any): void
 
+/**
+ * Register the process-wide native-event serializer hook.
+ *
+ * Installs the Node serializer (see [`node_native_to_json`]) used by
+ * [`DynamicEvent.toJson`](blazen_events::DynamicEvent) to lazily materialize
+ * native-backed events. Idempotent — the first registration wins. This is
+ * invoked automatically at module load, but is exposed for API parity with
+ * the other language bindings.
+ */
+export declare function registerNativeSerializer(): void
+
 /**
  * Register (or overwrite) pricing for a model.
  *
@@ -8958,9 +10915,9 @@ export interface RetryStack {
  * that resolves to one).
  *
  * ```typescript
- * import { CompletionModel, ChatMessage, runAgent } from 'blazen';
+ * import { Model, ChatMessage, runAgent } from 'blazen';
  *
- * const model = CompletionModel.openai({ apiKey: "sk-..." });
+ * const model = Model.openai({ apiKey: "sk-..." });
  *
  * const result = await runAgent(
  *   model,
@@ -8974,7 +10931,7 @@ export interface RetryStack {
  * );
  * ```
  */
-export declare function runAgent(model: JsCompletionModel, messages: Array<JsChatMessage>, tools: Array<JsToolDef>, toolHandler: ToolHandlerTsfn, options?: JsAgentRunOptions | undefined | null): Promise<AgentResult>
+export declare function runAgent(model: JsModel, messages: Array<JsChatMessage>, tools: Array<JsToolDef>, toolHandler: ToolHandlerTsfn, options?: JsAgentRunOptions | undefined | null): Promise<AgentResult>
 
 /**
  * Run an agent loop with an event-observer callback.
@@ -8985,9 +10942,9 @@ export declare function runAgent(model: JsCompletionModel, messages: Array<JsCha
  * abort the loop.
  *
  * ```typescript
- * import { CompletionModel, ChatMessage, runAgentWithCallback } from 'blazen';
+ * import { Model, ChatMessage, runAgentWithCallback } from 'blazen';
  *
- * const model = CompletionModel.openai({ apiKey: "sk-..." });
+ * const model = Model.openai({ apiKey: "sk-..." });
  *
  * const result = await runAgentWithCallback(
  *   model,
@@ -9001,7 +10958,7 @@ export declare function runAgent(model: JsCompletionModel, messages: Array<JsCha
  * );
  * ```
  */
-export declare function runAgentWithCallback(model: JsCompletionModel, messages: Array<JsChatMessage>, tools: Array<JsToolDef>, toolHandler: ToolHandlerTsfn, onEvent: AgentEventCallbackTsfn, options?: JsAgentRunOptions | undefined | null): Promise<AgentResult>
+export declare function runAgentWithCallback(model: JsModel, messages: Array<JsChatMessage>, tools: Array<JsToolDef>, toolHandler: ToolHandlerTsfn, onEvent: AgentEventCallbackTsfn, options?: JsAgentRunOptions | undefined | null): Promise<AgentResult>
 
 /**
  * Payload returned by [`JsContext::get_session_ref_serializable`].
@@ -9085,6 +11042,25 @@ export declare function simhashFromHex(hex: string): string
  */
 export declare function simhashToHex(value: string): string
 
+/**
+ * Configuration for the Spark-TTS backend.
+ *
+ * Mirrors [`blazen_llm::SparkTtsConfig`]. All fields are optional; unset
+ * fields fall back to the upstream defaults
+ * (`SparkAudio/Spark-TTS-0.5B`, HF download on first use).
+ */
+export interface SparkTtsConfig {
+  /** Hugging Face repo id for the Spark-TTS bundle. */
+  modelId?: string
+  /**
+   * Pre-resolved bundle directory. When unset, the bundle is
+   * downloaded and cached on first synthesis.
+   */
+  modelDir?: string
+  /** Optional revision (branch / tag / commit SHA) to pin against. */
+  revision?: string
+}
+
 /** Options for constructing a [`JsStartEventClass`] from JavaScript. */
 export interface StartEventOptions {
   /** Arbitrary payload passed into the workflow at start. */
@@ -9264,6 +11240,27 @@ export interface ToolOutput {
   llmOverride?: LlmPayload
 }
 
+/**
+ * Runtime configuration for the tracing wrapper installed by
+ * [`JsModel::with_tracing`](JsModel::with_tracing).
+ *
+ * Defaults are privacy-safe: token counts, model id, provider, and finish
+ * reason are always recorded; the raw prompt + completion message text is
+ * captured only when `captureMessages` is `true`.
+ *
+ * ```javascript
+ * const traced = Model.openai({ apiKey }).withTracingConfig({ captureMessages: true });
+ * ```
+ */
+export interface TracingConfig {
+  /**
+   * Capture raw prompt + completion message text as span attributes
+   * (`llm.input_messages` / `llm.output_messages`). Defaults to `false`.
+   * Leave off for privacy-sensitive deployments.
+   */
+  captureMessages?: boolean
+}
+
 /**
  * Attempt to deserialize an event payload using the registry.
  *
@@ -9418,6 +11415,30 @@ export interface ContentHint {
   byteSize?: number | null
 }
 
+// --- post-build: Event interface (workflow step surface) ---
+/**
+ * An event flowing through a {@link Workflow}. Every event is a plain
+ * object whose `type` string routes it to the steps that declared it in
+ * their `eventTypes`. All other fields are arbitrary user payload.
+ *
+ * Returned from / passed to step handlers (`addStep`), emitted via
+ * `ctx.sendEvent` / `ctx.writeEventToStream`, wrapped by
+ * `StepOutput.single` / `StepOutput.multiple`, and delivered to the
+ * `streamEvents` / `runStreaming` callbacks.
+ *
+ * Object identity is preserved across step hops: the exact object a
+ * handler returns is the same object the next matching handler
+ * receives (methods, class prototype, and non-JSON fields included).
+ */
+export interface Event {
+  /** Event type discriminant used for step routing, e.g. `"blazen::StartEvent"`. */
+  type: string
+  /** Result payload carried by `blazen::StopEvent`. */
+  result?: any
+  /** Arbitrary user payload fields. */
+  [key: string]: any
+}
+
 // --- post-build: typed error classes ---
 export class BlazenError extends Error {}
 export class AuthError extends BlazenError {}
@@ -9441,11 +11462,13 @@ export class LlamaCppInvalidOptionsError extends LlamaCppError {}
 export class LlamaCppModelLoadError extends LlamaCppError {}
 export class LlamaCppInferenceError extends LlamaCppError {}
 export class LlamaCppEngineNotAvailableError extends LlamaCppError {}
+export class LlamaCppAdapterFailedError extends LlamaCppError {}
 export class CandleLlmError extends ProviderError {}
 export class CandleLlmInvalidOptionsError extends CandleLlmError {}
 export class CandleLlmModelLoadError extends CandleLlmError {}
 export class CandleLlmInferenceError extends CandleLlmError {}
 export class CandleLlmEngineNotAvailableError extends CandleLlmError {}
+export class CandleLlmUnsupportedError extends CandleLlmError {}
 export class CandleEmbedError extends ProviderError {}
 export class CandleEmbedInvalidOptionsError extends CandleEmbedError {}
 export class CandleEmbedModelLoadError extends CandleEmbedError {}
@@ -9457,6 +11480,7 @@ export class MistralRsInvalidOptionsError extends MistralRsError {}
 export class MistralRsInitError extends MistralRsError {}
 export class MistralRsInferenceError extends MistralRsError {}
 export class MistralRsEngineNotAvailableError extends MistralRsError {}
+export class MistralRsAdapterFailedError extends MistralRsError {}
 export class WhisperError extends ProviderError {}
 export class WhisperInvalidOptionsError extends WhisperError {}
 export class WhisperModelLoadError extends WhisperError {}
@@ -9472,6 +11496,7 @@ export class DiffusionError extends ProviderError {}
 export class DiffusionInvalidOptionsError extends DiffusionError {}
 export class DiffusionModelLoadError extends DiffusionError {}
 export class DiffusionGenerationError extends DiffusionError {}
+export class DiffusionEngineNotAvailableError extends DiffusionError {}
 export class FastEmbedError extends ProviderError {}
 export class EmbedUnknownModelError extends FastEmbedError {}
 export class EmbedInitError extends FastEmbedError {}
@@ -9506,4 +11531,17 @@ export class CacheError extends BlazenError {}
 export class DownloadError extends CacheError {}
 export class CacheDirError extends CacheError {}
 export class IoError extends CacheError {}
-export declare function enrichError(err: unknown): unknown
+export class MusicError extends BlazenError {}
+export class MusicEngineNotAvailableError extends MusicError {}
+export class MusicNotYetImplementedError extends MusicError {}
+export class MusicHfHubError extends MusicError {}
+export class MusicIoError extends MusicError {}
+export class MusicCandleError extends MusicError {}
+export class MusicInvalidInputError extends MusicError {}
+export class VcError extends BlazenError {}
+export class VcEngineNotAvailableError extends VcError {}
+export class VcModelLoadError extends VcError {}
+export class VcConversionError extends VcError {}
+export class VcVoiceNotFoundError extends VcError {}
+export class VcUnsupportedError extends VcError {}
+export class VcIoError extends VcError {}