@xybrid/react-native 0.10.0-rc1

package/lib/typescript/index.d.ts

@@ -0,0 +1,28 @@
+export { Xybrid, type XybridInitOptions } from './xybrid';
+export { Model, ModelDownload, ModelLoader, type ModelSource, type RunOptions, } from './model';
+export { ConversationContext } from './context';
+export { Pipeline } from './pipeline';
+export { StreamingSession } from './session';
+export { Envelope } from './envelope';
+export { GenerationConfigs, creative, greedy } from './presets';
+export { XybridErrorCodes, isRetryable, isXybridError, type XybridError, type XybridErrorCode, } from './errors';
+export type { AbortSignalLike } from './cancel';
+export { bytesToBase64, float32ToBase64 } from './base64';
+export type { AbortSignalKind, AudioEnvelope, CacheEntry, CacheEntryLocation, CacheStatus, ConversationInfo, DownloadState, DownloadStatus, EmbeddingEnvelope, EnvelopeKind, EnvelopeMetadata, ExecutionTarget, GenerationConfig, ImageEnvelope, ImageFormat, InferenceMetrics, InferenceResult, MessageRole, ModelInfo, MultiPartEnvelope, OutputType, PartialResult, PipelineInfo, PipelineResult, StageLatency, StageResult, StreamToken, StreamingConfig, TextEnvelope, ThermalState, ToolCall, ToolDefinition, ToolResult, VoiceInfo, } from './types';
+/**
+ * Convert a JSON Schema (object or JSON string) into a GBNF grammar for
+ * `generationConfig.grammar`, so a local LLM emits schema-valid JSON. Runs the
+ * same native converter every binding uses; rejects with
+ * `xybrid_config_error` on invalid JSON or an unsupported construct.
+ *
+ * ```ts
+ * const grammar = await jsonSchemaToGbnf({
+ *   type: 'object',
+ *   properties: { name: { type: 'string' } },
+ *   required: ['name'],
+ * });
+ * const result = await model.run(prompt, { generationConfig: { grammar } });
+ * ```
+ */
+export declare function jsonSchemaToGbnf(schema: object | string): Promise<string>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EACL,KAAK,EACL,aAAa,EACb,WAAW,EACX,KAAK,WAAW,EAChB,KAAK,UAAU,GAChB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,KAAK,WAAW,EAChB,KAAK,eAAe,GACrB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE1D,YAAY,EACV,eAAe,EACf,aAAa,EACb,UAAU,EACV,kBAAkB,EAClB,WAAW,EACX,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,WAAW,EACX,WAAW,EACX,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,UAAU,EACV,SAAS,GACV,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAIzE"}

package/lib/typescript/model.d.ts

@@ -0,0 +1,211 @@
+import { type AbortSignalLike } from './cancel';
+import type { ConversationContext } from './context';
+import { StreamingSession } from './session';
+import type { AbortSignalKind, DownloadStatus, Envelope, GenerationConfig, InferenceResult, ModelInfo, StreamToken, StreamingConfig, VoiceInfo } from './types';
+/**
+ * Per-call options, mirroring bolt's `XybridRunOptions` plus the two handles
+ * the other SDKs pass as separate arguments (a conversation context and a
+ * stop button).
+ */
+export interface RunOptions {
+    /** Sampling parameters for LLM inference. */
+    generationConfig?: GenerationConfig;
+    /** Device-stress signals that abort the run early. */
+    abortOn?: AbortSignalKind[];
+    /** Allow this call to fall back to the cloud gateway under device stress. */
+    fallbackToCloud?: boolean;
+    /** Tokens to emit after an abort signal before stopping. */
+    maxGraceTokens?: number;
+    /** Correlation id threaded into telemetry for this call. */
+    correlationId?: string;
+    /**
+     * Seed the run with this conversation's history (multi-turn chat). The
+     * context is not modified: push the turns you want to keep yourself.
+     */
+    context?: ConversationContext;
+    /**
+     * Stop button. Aborting stops generation at the next token boundary. A
+     * batch `run` is only cancellable before generation starts; use
+     * `runStreaming` when a mid-flight stop matters.
+     */
+    signal?: AbortSignalLike;
+}
+/** Where a model comes from. Build one with the {@link ModelLoader} factories. */
+export type ModelSource = {
+    kind: 'registry';
+    id: string;
+} | {
+    kind: 'registrySpeculative';
+    id: string;
+} | {
+    kind: 'bundle';
+    path: string;
+} | {
+    kind: 'directory';
+    path: string;
+} | {
+    kind: 'huggingFace';
+    repo: string;
+    revision?: string;
+} | {
+    kind: 'modelFile';
+    path: string;
+};
+/**
+ * A cheap description of a model. Creating one does no I/O; {@link load}
+ * resolves, downloads if needed, and loads it.
+ */
+export declare class ModelLoader {
+    readonly source: ModelSource;
+    private constructor();
+    /** Describe any source. */
+    static from(source: ModelSource): ModelLoader;
+    /** A model from the Xybrid registry. The recommended path. */
+    static fromRegistry(id: string): ModelLoader;
+    /**
+     * Serve from the cloud gateway while the registry weights download in the
+     * background, instead of blocking on the download. `load()` then resolves
+     * almost immediately with a model that switches to on-device by itself.
+     * Needs an API key and an uncached model — {@link willSpeculate} tells you
+     * up front — otherwise it behaves like {@link fromRegistry}. LLM/chat only.
+     */
+    static fromRegistrySpeculative(id: string): ModelLoader;
+    /** A local `.xyb` bundle. */
+    static fromBundle(path: string): ModelLoader;
+    /** A local directory containing `model_metadata.json`. */
+    static fromDirectory(path: string): ModelLoader;
+    /** A Hugging Face repository (`org/repo` or `org/repo:variant`), optionally pinned. */
+    static fromHuggingFace(repo: string, options?: {
+        revision?: string;
+    }): ModelLoader;
+    /** A raw GGUF file; `model_metadata.json` is generated next to it if absent. */
+    static fromModelFile(path: string): ModelLoader;
+    /** Resolve, download if needed, and load. Rejects with a typed `xybrid_*` code. */
+    load(): Promise<Model>;
+    /**
+     * Whether {@link load} would actually speculate: a speculative source, an
+     * API key, and a model not yet cached. Never touches the network.
+     */
+    willSpeculate(): Promise<boolean>;
+    /**
+     * Start downloading the weights in the background without loading them —
+     * the object to drive a progress bar from. The download fills the cache, so
+     * the {@link load} afterwards returns at once. Resolves `null` for sources
+     * with nothing to fetch (bundle, directory, Hugging Face, model file).
+     */
+    download(options?: {
+        platform?: string;
+    }): Promise<ModelDownload | null>;
+}
+/** A model loaded in native memory. Call {@link release} when done with it. */
+export declare class Model {
+    /** Opaque native handle — not the model id; see {@link info}. */
+    readonly handle: string;
+    /** @internal Use {@link ModelLoader.load}. */
+    constructor(
+    /** Opaque native handle — not the model id; see {@link info}. */
+    handle: string);
+    /** Identity and capabilities, in one native call. */
+    info(): Promise<ModelInfo>;
+    /** Whether the weights are resident (false after {@link unload} until the next run). */
+    isLoaded(): Promise<boolean>;
+    /**
+     * Run one inference. Pass sampling parameters under `generationConfig`,
+     * a conversation under `context`, and an `AbortSignal` under `signal`.
+     */
+    run(envelope: Envelope, options?: RunOptions): Promise<InferenceResult>;
+    /**
+     * Stream inference token by token. Yields each {@link StreamToken}; the
+     * final {@link InferenceResult} is the generator's return value.
+     *
+     * ```ts
+     * for await (const token of model.runStreaming(Envelope.text('Hi'))) {
+     *   setText((prev) => prev + token.token);
+     * }
+     * ```
+     *
+     * Generation stops natively when iteration ends — completion, `break`, a
+     * thrown error, or an aborted `signal`. A generator that is merely
+     * abandoned is never cleaned up (JS runs no `finally` on GC), so on
+     * unmount abort the signal or call `gen.return()`.
+     *
+     * When the turn ends on tool calls, the terminal token carries `toolCalls`
+     * and `rawText` (pass it to `Envelope.toolResults`).
+     */
+    runStreaming(envelope: Envelope, options?: RunOptions): AsyncGenerator<StreamToken, InferenceResult | undefined, void>;
+    /**
+     * Open a live ASR session: feed microphone PCM in, read partial transcripts
+     * out. Audio must be Float32, mono, 16 kHz. Rejects with
+     * `xybrid_streaming_unsupported` for a model that cannot stream.
+     */
+    stream(config?: StreamingConfig): Promise<StreamingSession>;
+    /** Prime the model so first-token latency measures inference, not cold start. */
+    warmup(): Promise<void>;
+    /**
+     * Free the weights while keeping this handle valid — the next run reloads
+     * them. Contrast with {@link release}, which frees the handle.
+     */
+    unload(): Promise<void>;
+    /**
+     * Whether runs are currently answered by the cloud because the local
+     * weights aren't ready (speculative loads). Predicts the next run;
+     * `InferenceResult.executionTarget` reports what a finished run did.
+     */
+    isCloudServing(): Promise<boolean>;
+    /** Download progress of a speculative load; `ready` at 1.0 for local models. */
+    downloadStatus(): Promise<DownloadStatus>;
+    /**
+     * Yield the speculative download's status whenever it changes, ending
+     * after a terminal state. A local model yields one `ready` frame.
+     */
+    downloadProgress(options?: {
+        intervalMs?: number;
+    }): AsyncGenerator<DownloadStatus, void, void>;
+    /**
+     * Wait natively until the download settles or `timeoutMs` elapses, then
+     * report it. `0` makes it a non-blocking read.
+     */
+    awaitDownload(timeoutMs: number): Promise<DownloadStatus>;
+    /** TTS voices; empty for models without voices. */
+    voices(): Promise<VoiceInfo[]>;
+    /** The default TTS voice, if the model has voices. */
+    defaultVoice(): Promise<VoiceInfo | null>;
+    /** One TTS voice by id. */
+    voice(voiceId: string): Promise<VoiceInfo | null>;
+    /**
+     * Free the native model — weights live in the native heap, so release
+     * models you no longer need. Also stops token streams started from it.
+     * Later calls on this instance reject with `xybrid_handle`.
+     */
+    release(): Promise<void>;
+}
+/**
+ * A model download running in the background, separate from loading. Start
+ * one with {@link ModelLoader.download}. Releasing the handle does not stop
+ * the transfer — call {@link cancel}.
+ */
+export declare class ModelDownload {
+    readonly handle: string;
+    /** @internal */
+    constructor(handle: string);
+    /** Progress, bytes and state in one consistent read. */
+    status(): Promise<DownloadStatus>;
+    /** The failure message once the download failed, else `null`. */
+    error(): Promise<string | null>;
+    /** Stop the transfer. The status then settles on `cancelled`. */
+    cancel(): Promise<void>;
+    /**
+     * Yield the status whenever it changes, ending after a terminal state
+     * (`ready`, `failed`, `cancelled`). Polls natively every `intervalMs`.
+     *
+     * ```ts
+     * for await (const s of download.progress()) setProgress(s.progress);
+     * ```
+     */
+    progress(options?: {
+        intervalMs?: number;
+    }): AsyncGenerator<DownloadStatus, void, void>;
+    /** Free the handle (the transfer keeps going unless cancelled). */
+    release(): Promise<void>;
+}
+//# sourceMappingURL=model.d.ts.map

package/lib/typescript/model.d.ts.map

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

package/lib/typescript/pipeline.d.ts

@@ -0,0 +1,35 @@
+import type { Envelope, PipelineInfo, PipelineResult } from './types';
+/**
+ * A multi-stage pipeline (e.g. ASR → LLM → TTS) defined in YAML. A run
+ * returns every stage's output, so a voice assistant can show what it heard
+ * and what it answered while it plays the audio:
+ *
+ * ```ts
+ * const pipeline = await Pipeline.fromFile(path);
+ * const result = await pipeline.run(Envelope.audio(pcmBase64));
+ * const heard = result.stages.find((s) => s.stageId === 'asr')?.text;
+ * ```
+ */
+export declare class Pipeline {
+    /** Opaque native handle. */
+    readonly handle: string;
+    private constructor();
+    /** Parse and load a pipeline from YAML content. */
+    static fromYaml(yaml: string): Promise<Pipeline>;
+    /** Read, parse and load a pipeline YAML file. */
+    static fromFile(path: string): Promise<Pipeline>;
+    /** Load a pipeline bundle. */
+    static fromBundle(path: string): Promise<Pipeline>;
+    /** Name and stage ids, in execution order. */
+    info(): Promise<PipelineInfo>;
+    /**
+     * Run every stage, downloading any missing model first. Per-stage
+     * generation settings belong in the YAML; only `correlationId` applies here.
+     */
+    run(envelope: Envelope, options?: {
+        correlationId?: string;
+    }): Promise<PipelineResult>;
+    /** Free the native pipeline. */
+    release(): Promise<void>;
+}
+//# sourceMappingURL=pipeline.d.ts.map

package/lib/typescript/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAOtE;;;;;;;;;;GAUG;AACH,qBAAa,QAAQ;IAEjB,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM;IAFzB,OAAO;IAKP,mDAAmD;WACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAItD,iDAAiD;WACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAItD,8BAA8B;WACjB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IAIxD,8CAA8C;IACxC,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC;IAInC;;;OAGG;IACG,GAAG,CACP,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAO,GACvC,OAAO,CAAC,cAAc,CAAC;IAS1B,gCAAgC;IAChC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAGzB"}

package/lib/typescript/presets.d.ts

@@ -0,0 +1,21 @@
+import type { GenerationConfig, ToolDefinition } from './types';
+/**
+ * Greedy decoding (deterministic, temperature 0): the usual choice for
+ * extraction and tool calling.
+ */
+export declare function greedy(options?: {
+    maxTokens?: number;
+    grammar?: string;
+    tools?: ToolDefinition[];
+}): GenerationConfig;
+/** Higher temperature, for more varied output. */
+export declare function creative(options?: {
+    maxTokens?: number;
+    tools?: ToolDefinition[];
+}): GenerationConfig;
+/** Preset factories for {@link GenerationConfig}. */
+export declare const GenerationConfigs: {
+    greedy: typeof greedy;
+    creative: typeof creative;
+};
+//# sourceMappingURL=presets.d.ts.map

package/lib/typescript/presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAKhE;;;GAGG;AACH,wBAAgB,MAAM,CACpB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,cAAc,EAAE,CAAA;CAAO,GAC/E,gBAAgB,CAQlB;AAED,kDAAkD;AAClD,wBAAgB,QAAQ,CACtB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,cAAc,EAAE,CAAA;CAAO,GAC7D,gBAAgB,CAQlB;AAED,qDAAqD;AACrD,eAAO,MAAM,iBAAiB;;;CAAuB,CAAC"}

package/lib/typescript/session.d.ts

@@ -0,0 +1,50 @@
+import type { PartialResult } from './types';
+/**
+ * A live ASR session: feed microphone PCM in, read partial transcripts out.
+ * Open one with `model.stream()`.
+ *
+ * ```ts
+ * const session = await model.stream();
+ * (async () => {
+ *   for await (const partial of session.partials()) setCaption(partial.text);
+ * })();
+ * // from your audio callback (Float32, mono, 16 kHz):
+ * await session.feed(samples);
+ * // when the user stops talking:
+ * const transcript = await session.flush();
+ * await session.release();
+ * ```
+ */
+export declare class StreamingSession {
+    /** Opaque native handle. */
+    readonly handle: string;
+    /** @internal Use `model.stream()`. */
+    constructor(
+    /** Opaque native handle. */
+    handle: string);
+    /**
+     * Queue PCM samples (Float32, mono, 16 kHz). Transcription happens off the
+     * JS thread; this only waits when the native queue is full.
+     */
+    feed(samples: Float32Array | ArrayLike<number>): Promise<void>;
+    /**
+     * Partial transcripts as they arrive, ending when the session finishes
+     * (after {@link flush} or {@link cancel}). Each partial is cumulative:
+     * render it in place of the previous one. Use one iterator per session.
+     */
+    partials(): AsyncGenerator<PartialResult, void, void>;
+    /**
+     * Drain the buffered audio and return the complete transcript. The session
+     * is over afterwards.
+     */
+    flush(): Promise<string>;
+    /** Start over on fresh audio without reloading the model. */
+    reset(): Promise<void>;
+    /** Stop and discard buffered audio — the "user walked away" path. */
+    cancel(): Promise<void>;
+    /** Whether the session still accepts audio. */
+    isRunning(): Promise<boolean>;
+    /** Free the native session (cancelling it if still running). */
+    release(): Promise<void>;
+}
+//# sourceMappingURL=session.d.ts.map

package/lib/typescript/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,gBAAgB;IAGzB,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM;IAHzB,sCAAsC;;IAEpC,4BAA4B;IACnB,MAAM,EAAE,MAAM;IAGzB;;;OAGG;IACH,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D;;;;OAIG;IACI,QAAQ,IAAI,cAAc,CAAC,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC;IAQ5D;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAIxB,6DAA6D;IAC7D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,qEAAqE;IACrE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,+CAA+C;IAC/C,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAI7B,gEAAgE;IAChE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAGzB"}