kjarni-wasm 0.1.4

package/pkg/kjarni_wasm.d.ts

@@ -0,0 +1,259 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A local language model running in the browser.
+ *
+ * Text generation is synchronous here, and deliberately so. The engine's streaming
+ * path builds a background task with `tokio::task::spawn_blocking`, and wasm has no
+ * blocking pool for that to run on — it compiles but would fail at runtime. Calling
+ * the generation loop directly and draining the channel afterwards avoids the
+ * problem entirely.
+ *
+ * The cost is that a call blocks until the whole response is ready, which for a few
+ * hundred tokens is seconds, not milliseconds. Run it in a Web Worker; on the main
+ * thread it will freeze the tab.
+ */
+export class WasmChat {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * The model's context window, in tokens.
+     */
+    context_size(): number;
+    /**
+     * Generate a completion for `prompt`.
+     */
+    generate(prompt: string, max_new_tokens: number, temperature: number): string;
+    /**
+     * Generate a completion, invoking `on_token` with each piece as it arrives.
+     *
+     * The callback runs on whichever thread called this, synchronously between
+     * decoding steps. On the main thread that still blocks the page, so this is
+     * meant to be driven from a Web Worker; the `kjarni-wasm` npm wrapper does
+     * exactly that and turns it into an async iterator.
+     *
+     * Returning `false` from the callback does not stop generation yet; the
+     * value is ignored.
+     *
+     * Browser-only: `js_sys::Function` has no native equivalent. The streaming
+     * itself is in `generate_stream_core`, which builds and is tested natively.
+     */
+    generate_stream(prompt: string, max_new_tokens: number, temperature: number, on_token: Function): string;
+    /**
+     * Load a decoder model from a `.kjq` container.
+     *
+     * `model_id` selects the chat template, e.g. `qwen2.5-0.5b-instruct`. Without
+     * one the model still generates, but its turn markers will not be applied.
+     */
+    static load(data: Uint8Array, model_id?: string | null): WasmChat;
+}
+
+/**
+ * Sequence classification: sentiment, emotion, toxicity.
+ *
+ * New to the browser. Classification was always in the engine but never had a
+ * binding here, because this crate previously carried its own encoder and nobody
+ * wrote a second classifier head for it.
+ */
+export class WasmClassifier {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Classify one text, returning every label with its score, highest first.
+     *
+     * Serializing to a `JsValue` panics outside wasm32, so the work lives in
+     * [`WasmClassifier::classify_core`] and this is only the conversion. That is
+     * what makes the behaviour testable on the host.
+     */
+    classify(text: string): any;
+    /**
+     * Classify a batch, returning the single best label for each input.
+     *
+     * One result per input, in input order, so the caller can line them up with
+     * whatever it passed in.
+     */
+    classify_batch(texts: string[]): any;
+    /**
+     * The labels this model predicts, in index order.
+     */
+    labels(): string[];
+    /**
+     * Load a classifier from a `.kjq` container.
+     */
+    static load(data: Uint8Array): WasmClassifier;
+    /**
+     * How many labels the model predicts.
+     */
+    num_labels(): number;
+}
+
+export class WasmEncoder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    encode_file(text: string, source_path: string): any;
+    static new(model_data: Uint8Array): WasmEncoder;
+}
+
+export class WasmIndexBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_chunk(text: string, embedding: Float32Array, source: string, chunk_index: number): void;
+    add_file(text: string, source_path: string): number;
+    doc_count(): number;
+    finish(): Uint8Array;
+    static new(model_data: Uint8Array): WasmIndexBuilder;
+}
+
+export class WasmModel {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Encode a batch, returning every vector concatenated into one flat array.
+     *
+     * The engine's encode is `async` because the GPU path awaits buffer readback.
+     * There is no GPU path here, and the wasm CPU implementation contains no await
+     * at all, so the future is always ready on its first poll and `block_on`
+     * returns without ever parking the browser's main thread.
+     */
+    encode(texts: string[], normalize: boolean): Float32Array;
+    /**
+     * Load from a `.kjq` container: config, tokenizer and int8 tensors in one file.
+     */
+    static from_quantized(data: Uint8Array): WasmModel;
+    /**
+     * Fetch a model straight from Hugging Face. Browser-only: it uses `fetch`.
+     */
+    static from_type(model_type: WasmModelType): Promise<WasmModel>;
+    /**
+     * Load from raw safetensors plus its config and tokenizer.
+     */
+    constructor(weights_data: Uint8Array, config_json: string, tokenizer_json: string);
+}
+
+export enum WasmModelType {
+    MiniLML6V2 = 0,
+}
+
+export class WasmReranker {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Load a cross-encoder from a `.kjq` container.
+     *
+     * The classifier head used to be pulled out of the weights by hand here; the
+     * engine's `CrossEncoder` loads it as part of the model.
+     */
+    static load(data: Uint8Array): WasmReranker;
+    /**
+     * Score every document against the query and return the best `limit`,
+     * highest first. Scores are raw logits, so negative values are normal.
+     */
+    rerank(query: string, documents: string[], limit: number): any;
+    /**
+     * Score a single query-document pair.
+     */
+    score(query: string, document: string): number;
+}
+
+export class WasmSearch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_chunk(text: string, embedding: Float32Array, source: string, chunk_index: number): void;
+    doc_count(): number;
+    static load(model_data: Uint8Array, index_data: Uint8Array): WasmSearch;
+    remove_file(source_path: string): number;
+    save_index(): Uint8Array;
+    search(query: string, limit: number): any;
+    search_keywords(query: string, limit: number): any;
+    search_semantic(query: string, limit: number): any;
+    update_file(text: string, source_path: string): number;
+}
+
+export function init(): void;
+
+export function set_debug_logging(enabled: boolean): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_wasmchat_free: (a: number, b: number) => void;
+    readonly __wbg_wasmclassifier_free: (a: number, b: number) => void;
+    readonly __wbg_wasmencoder_free: (a: number, b: number) => void;
+    readonly __wbg_wasmindexbuilder_free: (a: number, b: number) => void;
+    readonly __wbg_wasmmodel_free: (a: number, b: number) => void;
+    readonly set_debug_logging: (a: number) => void;
+    readonly wasmchat_context_size: (a: number) => number;
+    readonly wasmchat_generate: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmchat_generate_stream: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly wasmchat_load: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wasmclassifier_classify: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmclassifier_classify_batch: (a: number, b: number, c: number, d: number) => void;
+    readonly wasmclassifier_labels: (a: number, b: number) => void;
+    readonly wasmclassifier_load: (a: number, b: number, c: number) => void;
+    readonly wasmclassifier_num_labels: (a: number) => number;
+    readonly wasmencoder_encode_file: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmencoder_new: (a: number, b: number, c: number) => void;
+    readonly wasmindexbuilder_add_chunk: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly wasmindexbuilder_add_file: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmindexbuilder_doc_count: (a: number) => number;
+    readonly wasmindexbuilder_finish: (a: number, b: number) => void;
+    readonly wasmindexbuilder_new: (a: number, b: number, c: number) => void;
+    readonly wasmmodel_encode: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wasmmodel_from_quantized: (a: number, b: number, c: number) => void;
+    readonly wasmmodel_from_type: (a: number) => number;
+    readonly wasmmodel_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly wasmreranker_load: (a: number, b: number, c: number) => void;
+    readonly wasmreranker_rerank: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly wasmreranker_score: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly wasmsearch_load: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wasmsearch_remove_file: (a: number, b: number, c: number) => number;
+    readonly wasmsearch_save_index: (a: number, b: number) => void;
+    readonly wasmsearch_search: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wasmsearch_search_keywords: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wasmsearch_search_semantic: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wasmsearch_update_file: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly init: () => void;
+    readonly wasmsearch_doc_count: (a: number) => number;
+    readonly wasmsearch_add_chunk: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly __wbg_wasmreranker_free: (a: number, b: number) => void;
+    readonly __wbg_wasmsearch_free: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_5410: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_5426: (a: number, b: number, c: number, d: number) => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export5: (a: number, b: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;