@inbrowser/model 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,291 @@
+/**
+ * Public types for `@inbrowser/model`.
+ *
+ * Vocabulary anchor:
+ *   - `ModelRef`     — bare locator (HF Hub repo id + revision).
+ *   - `ModelPreset`  — locator + static config (dtype, backend,
+ *                      capabilities, optional chat template).
+ *   - `Engine`       — runtime object owning a loaded model.
+ *                      Spread a preset into `createEngine` to get one.
+ *
+ * The Engine speaks a narrow `EngineEvent` vocabulary. Adapters in
+ * `./adapters/*` translate to the relay's `InferenceEvent` or the
+ * agent's `ChatEvent` shape. Cloud-only concepts (cost, signatures)
+ * are deliberately absent here.
+ */
+/**
+ * HF Hub repo id + optional revision. Pin a revision for
+ * reproducibility — `main` drifts.
+ */
+export interface ModelRef {
+    modelId: string;
+    revision?: string;
+}
+/**
+ * ONNX Runtime Web execution backend.
+ *
+ *   - `'webgpu'` — WebGPU compute pipeline. Required for Gemma 4 perf.
+ *   - `'wasm'`   — SIMD CPU fallback. Always available, much slower.
+ *   - `'auto'`   — Probe `navigator.gpu`; fall back to wasm if absent.
+ */
+export type Backend = 'auto' | 'webgpu' | 'wasm';
+/**
+ * Weight/activation precision selection.
+ *
+ *   - `q4f16` — 4-bit int weights, fp16 activations. Recommended
+ *               default for Gemma 4 on WebGPU.
+ *   - `q8`    — 8-bit int weights. Larger, sometimes higher quality.
+ *   - `fp16`  — half precision throughout.
+ *   - `fp32`  — full precision (rarely useful in-browser).
+ */
+export type Dtype = 'q4f16' | 'q8' | 'fp16' | 'fp32';
+/**
+ * Static, pre-load capability declaration. Lives on `ModelPreset`
+ * so consumers can interrogate before paying load cost.
+ */
+export interface EngineCapabilities {
+    supportsTools: boolean;
+    supportsVision: boolean;
+    supportsAudio: boolean;
+    /** Context window in tokens. */
+    contextWindow: number;
+    /** Whether the model emits thinking traces when prompted. */
+    supportsThinking: boolean;
+    /**
+     * When `supportsThinking` is true and the consumer enables thinking
+     * via `GenerateOpts.enableThinking`, the model emits reasoning
+     * inside these tags. Models vary:
+     *
+     *   - DeepSeek R1 / R1 Distill: `<think>…</think>` (literal text).
+     *     The model emits both open and close tags during generation.
+     *   - Gemma 4 / Gemma 3n: only `<channel|>` is emitted (close).
+     *     The chat template's `add_generation_prompt` pre-fills the
+     *     `<|channel>thought\n` open marker into the prompt, so
+     *     generation starts inside thinking. Configure with
+     *     `implicitOpen: true`. The Gemma end-of-turn marker `<turn|>`
+     *     leaks when `skip_special_tokens: false` is set; strip via
+     *     `stripTokens: ['<turn|>']`.
+     *
+     * Consumers thread these into `splitThinking()` to route reasoning
+     * to a dedicated UI surface. The full shape matches
+     * `ThinkingSplitOpts` so the preset can be spread directly.
+     */
+    thinkingTags?: {
+        openTag: string;
+        closeTag: string;
+        /** When true, the stream starts inside thinking (no open tag in output). */
+        implicitOpen?: boolean;
+        /** Literal substrings to strip from `token` events (structural leak tokens). */
+        stripTokens?: ReadonlyArray<string>;
+    };
+}
+/**
+ * A fully-specified model configuration. Spread into `createEngine`
+ * along with optional hooks. Authored via `definePreset` for
+ * compile-time completeness checks; community presets can be exported
+ * the same way.
+ */
+export interface ModelPreset {
+    model: ModelRef;
+    dtype: Dtype;
+    backend: Backend;
+    capabilities: EngineCapabilities;
+    /**
+     * Optional override of the chat template. The default uses the
+     * tokenizer's bundled template (`apply_chat_template`); override
+     * only when a model ships a broken or missing template.
+     */
+    chatTemplate?: (messages: ReadonlyArray<EngineMessage>) => string;
+}
+/**
+ * Granular progress for the three observable phases of cold start.
+ *
+ *   - `fetch`  — weights flowing from HF Hub (or `weightsBaseUrl`) into
+ *                the browser Cache API. Cached after first run.
+ *   - `init`   — ONNX Runtime compiling the graph for `backend`.
+ *                Per-page-load (not cached across reloads today).
+ *   - `warmup` — first forward pass primes WebGPU pipelines + kernel
+ *                caches. Once-per-engine-instance.
+ *   - `ready`  — terminal phase; safe to `generate`.
+ */
+export type LoadProgress = {
+    phase: 'fetch';
+    file: string;
+    loadedBytes: number;
+    totalBytes: number;
+} | {
+    phase: 'init';
+    backend: Backend;
+} | {
+    phase: 'warmup';
+    tokensGenerated: number;
+} | {
+    phase: 'ready';
+};
+export type EngineState = 'idle' | 'loading' | 'ready' | 'error' | 'disposed';
+/**
+ * Inline media for multimodal models. Gemma 4 accepts audio; future
+ * presets may set `supportsVision: true` and accept images.
+ */
+export type MediaPart = {
+    kind: 'image';
+    data: Blob | ArrayBuffer;
+    mimeType: string;
+} | {
+    kind: 'audio';
+    data: Blob | ArrayBuffer;
+    mimeType: string;
+};
+/**
+ * Engine-side chat message. Symmetric with agent's `NormalizedMessage`
+ * minus tool fields — the engine itself is toolless. Tool-use
+ * polyfilling lives upstream in `@inbrowser/agent`.
+ */
+export interface EngineMessage {
+    role: 'system' | 'user' | 'assistant';
+    text: string;
+    media?: ReadonlyArray<MediaPart>;
+}
+export interface GenerateOpts {
+    maxNewTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    /** Stop sequences enforced post-tokenization. */
+    stop?: ReadonlyArray<string>;
+    /** Caller-side cancellation. Aborting stops the decode loop. */
+    signal?: AbortSignal;
+    /**
+     * Tool declarations advertised to the model. Only honored when the
+     * active preset declares `capabilities.supportsTools: true`. When
+     * provided, the engine threads them through the tokenizer's chat
+     * template (`apply_chat_template({ messages, tools })`) and wraps
+     * the output stream with a tool-call parser so `kind: 'tool_call'`
+     * events are emitted when the model invokes a tool.
+     */
+    tools?: ReadonlyArray<ToolSpec>;
+    /**
+     * Opt into the model's thinking mode. Only honored when the active
+     * preset declares `capabilities.supportsThinking: true`. When set:
+     *
+     * 1. The engine passes `enable_thinking: true` to
+     *    `apply_chat_template` so the model's template renders its
+     *    thinking-mode preamble.
+     * 2. When the preset also declares `capabilities.thinkingTags`,
+     *    the engine sets `skip_special_tokens: false` on the
+     *    TextStreamer so the channel markers reach the output stream
+     *    (Gemma 4 family uses special tokens for this; DeepSeek uses
+     *    literal text).
+     *
+     * The reasoning text is still emitted as `kind: 'token'` events
+     * from the engine. Consumers wrap with `splitThinking()` (using
+     * `capabilities.thinkingTags` when present) to route it to a
+     * dedicated UI surface.
+     */
+    enableThinking?: boolean;
+}
+/**
+ * Tool declaration shape. Matches the OAI function-calling format
+ * that most modern chat templates (Qwen 2/3, DeepSeek R1, Llama 3.2+,
+ * Mistral v0.3+) accept directly.
+ */
+export interface ToolSpec {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: unknown;
+    };
+}
+/**
+ * Engine's narrow event vocabulary. Adapters translate to the wider
+ * shapes consumers expect (`InferenceEvent`, `ChatEvent`). No cost,
+ * no thoughtSignature, no cloud-specific extension fields.
+ *
+ *   - `token`    — decoded text per decode step.
+ *   - `thinking` — content the model emitted inside a reasoning-tag
+ *                  wrapper (e.g., `<think>…</think>` for DeepSeek R1).
+ *                  The engine itself never produces this kind; it's
+ *                  emitted by `splitThinking()` (see `./think.ts`) when
+ *                  a consumer wraps the engine's stream. The variant
+ *                  lives on `EngineEvent` so a single `switch (kind)`
+ *                  handles both wrapped and raw streams.
+ *   - `usage`    — terminal accounting, once per stream.
+ *   - `error`    — `recoverable` distinguishes retryable transients
+ *                  (decode hiccup) from terminal failures (OOM, dispose).
+ */
+export type EngineEvent = {
+    kind: 'token';
+    text: string;
+} | {
+    kind: 'thinking';
+    text: string;
+} | {
+    kind: 'tool_call';
+    /** Locally-generated id; the engine doesn't get one from the model. */
+    id: string;
+    /** Tool name as the model wrote it (may not be in the registered set — caller validates). */
+    name: string;
+    /** Parsed args. Plain object when JSON parsing succeeds; `{ _raw: string }` when malformed. */
+    args: unknown;
+} | {
+    kind: 'usage';
+    promptTokens: number;
+    outputTokens: number;
+    decodeMs: number;
+} | {
+    kind: 'error';
+    message: string;
+    recoverable: boolean;
+};
+/**
+ * Lifecycle event types `engine.on()` subscribes to.
+ */
+export interface EngineEventMap {
+    state: EngineState;
+    load: LoadProgress;
+}
+/**
+ * The runtime engine. Holds the loaded model + tokenizer/processor.
+ * One engine per model instance; spawn multiple to run different
+ * models in parallel (memory permitting).
+ */
+export interface Engine {
+    readonly model: ModelRef;
+    readonly state: EngineState;
+    /** Static capabilities — equal to `preset.capabilities` post-load. */
+    readonly capabilities: EngineCapabilities;
+    /** Idempotent. Resolves once state is `'ready'`. */
+    ensureReady(): Promise<void>;
+    on<K extends keyof EngineEventMap>(event: K, handler: (value: EngineEventMap[K]) => void): () => void;
+    generate(messages: ReadonlyArray<EngineMessage>, opts?: GenerateOpts): AsyncIterable<EngineEvent>;
+    /** Release GPU buffers + tokenizer state. Engine unusable after. */
+    dispose(): Promise<void>;
+}
+/**
+ * Non-preset construction options. Spread alongside a `ModelPreset`
+ * into `createEngine`.
+ */
+export interface EngineHooks {
+    /**
+     * Base URL for weight fetches. Defaults to huggingface.co. Set for
+     * self-hosted mirrors or offline bundles; the engine appends
+     * `{modelId}/{file}`.
+     */
+    weightsBaseUrl?: string;
+    /**
+     * Minimum reported GPU memory in MB. If the device reports less,
+     * `ensureReady()` rejects with `InsufficientMemoryError` rather than
+     * crashing mid-load.
+     */
+    minGpuMemoryMb?: number;
+    onLoadProgress?: (p: LoadProgress) => void;
+}
+/**
+ * Full argument shape for `createEngine`. A complete `ModelPreset`
+ * is required; hooks are optional.
+ *
+ *   createEngine({ ...gemma4_E2B, onLoadProgress: console.log });
+ */
+export type CreateEngineOpts = ModelPreset & EngineHooks;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,17 @@
+/**
+ * Public types for `@inbrowser/model`.
+ *
+ * Vocabulary anchor:
+ *   - `ModelRef`     — bare locator (HF Hub repo id + revision).
+ *   - `ModelPreset`  — locator + static config (dtype, backend,
+ *                      capabilities, optional chat template).
+ *   - `Engine`       — runtime object owning a loaded model.
+ *                      Spread a preset into `createEngine` to get one.
+ *
+ * The Engine speaks a narrow `EngineEvent` vocabulary. Adapters in
+ * `./adapters/*` translate to the relay's `InferenceEvent` or the
+ * agent's `ChatEvent` shape. Cloud-only concepts (cost, signatures)
+ * are deliberately absent here.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/worker.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Worker transport — host an `Engine` inside a Web Worker; expose
+ * the same `Engine` shape on the main thread via a postMessage RPC.
+ *
+ * The key invariant: `connectWorkerEngine` returns a value that
+ * satisfies the same `Engine` interface as `createEngine`. Anything
+ * downstream — adapters, agent runtime, UI — cannot tell whether it
+ * holds a direct engine or a remote stub.
+ *
+ * RPC framing is sequence-numbered; `generate` opens a per-call
+ * stream id and the worker side fans `EngineEvent`s back tagged
+ * with that id. Backpressure today is implicit (postMessage queue);
+ * a future revision may add explicit acks.
+ *
+ * Wire shape:
+ *
+ *   main → worker (ClientFrame)
+ *     init            — once, on connect; carries CreateEngineOpts
+ *     ensure-ready    — request the engine to load (seq-tracked ack/reject)
+ *     generate-start  — open a stream; events flow back tagged with seq
+ *     generate-abort  — request a stream to terminate (best effort)
+ *     dispose         — tear down engine + transport
+ *
+ *   worker → main (HostFrame)
+ *     init-ack        — handshake reply (model + capabilities echoed)
+ *     state           — engine state transitions
+ *     load            — LoadProgress events
+ *     ack | reject    — per-seq reply for ensure-ready / dispose
+ *     event           — a single EngineEvent for a generate stream
+ *     event-end       — terminal marker for a generate stream
+ */
+import type { CreateEngineOpts, Engine } from './types.js';
+export interface WorkerHostHandle {
+    dispose(): Promise<void>;
+}
+export interface HostEngineInWorkerOpts {
+    /**
+     * Factory the host uses to build the real engine after receiving
+     * `init` from the main thread. Default: `createEngine` from this
+     * package. Override only for testing.
+     */
+    factory?: (opts: CreateEngineOpts) => Engine;
+}
+/**
+ * Install the worker-side RPC. Call from inside your worker entry:
+ *
+ *   import { hostEngineInWorker } from '@inbrowser/model/worker';
+ *   hostEngineInWorker(self);
+ */
+export declare function hostEngineInWorker(workerScope: DedicatedWorkerGlobalScope, opts?: HostEngineInWorkerOpts): WorkerHostHandle;
+export interface ConnectWorkerEngineOpts {
+    worker: Worker;
+    engine: CreateEngineOpts;
+    /** Handshake timeout for the initial capabilities exchange. Default 10s. */
+    handshakeTimeoutMs?: number;
+}
+/**
+ * Connect to a worker that has called `hostEngineInWorker(self)`.
+ * Returns an `Engine` whose calls are RPC'd over postMessage.
+ */
+export declare function connectWorkerEngine(opts: ConnectWorkerEngineOpts): Engine;
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,OAAO,KAAK,EACV,gBAAgB,EAChB,MAAM,EASP,MAAM,YAAY,CAAC;AAiCpB,MAAM,WAAW,gBAAgB;IAC/B,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,gBAAgB,KAAK,MAAM,CAAC;CAC9C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,0BAA0B,EACvC,IAAI,CAAC,EAAE,sBAAsB,GAC5B,gBAAgB,CA6KlB;AAID,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,gBAAgB,CAAC;IACzB,4EAA4E;IAC5E,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAyRzE"}