@tanstack-ai-browser/wllama 0.0.0-stage → 0.2.1

package/dist/thinking.js

@@ -0,0 +1,140 @@
+/**
+ * Splitting a reply into thinking and answer. Copied from
+ * @tanstack-ai-browser/transformers-js (thinking.ts), so this package
+ * doesn't depend on that one and its worker.
+ */
+/** `<think>…</think>`, as LFM models (and most others) write it. */
+export const THINK_TAGS = {
+    open: "<think>",
+    close: "</think>"
+};
+/**
+ * Splits a model's reply into its thinking and its answer. Thinking is any
+ * `<think>…</think>` block (or the format's own markers), or everything
+ * before a lone close (models prompted with an empty `<think></think>`
+ * sometimes still think a little and close it). An open with no close yet
+ * means it's still thinking.
+ */
+export function splitThinking(text, { open: OPEN, close: CLOSE } = THINK_TAGS) {
+    const thoughts = [];
+    let rest = text;
+    let isThinking = false;
+    for (;;) {
+        const open = rest.indexOf(OPEN);
+        const close = rest.indexOf(CLOSE);
+        if (close !== -1 && (open === -1 || close < open)) {
+            // A close with no open: everything before it was thinking.
+            thoughts.push(rest.slice(0, close));
+            rest = rest.slice(close + CLOSE.length);
+            continue;
+        }
+        if (open === -1)
+            break;
+        const before = rest.slice(0, open);
+        const after = rest.slice(open + OPEN.length);
+        const end = after.indexOf(CLOSE);
+        if (end === -1) {
+            thoughts.push(after);
+            rest = before;
+            isThinking = true;
+            break;
+        }
+        thoughts.push(after.slice(0, end));
+        rest = before + after.slice(end + CLOSE.length);
+    }
+    return {
+        thinking: thoughts
+            .map((t) => t.trim())
+            .filter(Boolean)
+            .join("\n\n"),
+        answer: rest.trim(),
+        isThinking
+    };
+}
+/** Length of the longest end of `text` that could be the start of `tag`. */
+function partialTag(text, tag) {
+    for (let n = Math.min(tag.length - 1, text.length); n > 0; n--) {
+        if (tag.startsWith(text.slice(-n)))
+            return n;
+    }
+    return 0;
+}
+/**
+ * Splits a reply into thinking and answer while it streams. A reply that
+ * starts with the open marker (`<think>`) is thinking until the close
+ * (`</think>`); the rest is the answer. Markers split across tokens are held
+ * back until they are complete.
+ */
+export function createThinkingSplitter({ open: OPEN, close: CLOSE } = THINK_TAGS) {
+    let state = "start";
+    let buffer = "";
+    /** Whether the thinking has had any text yet (to drop a leading newline). */
+    let thought = false;
+    /** Whether the answer has had any text yet (to drop leading blank lines). */
+    let answered = false;
+    const answer = (text) => {
+        const out = answered ? text : text.trimStart();
+        if (!out)
+            return [];
+        answered = true;
+        return [{ kind: "answer", text: out }];
+    };
+    function push(text) {
+        buffer += text;
+        const pieces = [];
+        for (;;) {
+            if (state === "start") {
+                const lead = buffer.trimStart();
+                if (lead.startsWith(OPEN)) {
+                    buffer = lead.slice(OPEN.length);
+                    state = "thinking";
+                }
+                else if (OPEN.startsWith(lead)) {
+                    return pieces;
+                }
+                else {
+                    state = "answer";
+                }
+            }
+            else if (state === "thinking") {
+                const end = buffer.indexOf(CLOSE);
+                if (end === -1) {
+                    const keep = partialTag(buffer, CLOSE);
+                    const done = buffer.slice(0, buffer.length - keep);
+                    buffer = buffer.slice(done.length);
+                    const text = thought ? done : done.trimStart();
+                    if (text) {
+                        thought = true;
+                        pieces.push({ kind: "thinking", text });
+                    }
+                    return pieces;
+                }
+                const text = thought
+                    ? buffer.slice(0, end)
+                    : buffer.slice(0, end).trimStart();
+                if (text) {
+                    thought = true;
+                    pieces.push({ kind: "thinking", text });
+                }
+                buffer = buffer.slice(end + CLOSE.length);
+                state = "answer";
+            }
+            else {
+                pieces.push(...answer(buffer));
+                buffer = "";
+                return pieces;
+            }
+        }
+    }
+    /** Whatever is still held back, once the reply has ended. */
+    function flush() {
+        const rest = buffer;
+        buffer = "";
+        if (!rest)
+            return [];
+        return state === "thinking"
+            ? [{ kind: "thinking", text: rest }]
+            : answer(rest);
+    }
+    return { push, flush };
+}

package/dist/tool-calls.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Reading and writing tool calls the way LFM2 and LFM2.5 write them:
+ * Pythonic calls between markers,
+ * `<|tool_call_start|>[get_weather(city="Tokyo")]<|tool_call_end|>`.
+ *
+ * Copied from @tanstack-ai-browser/transformers-js (tool-calls.ts, its LFM2
+ * parts), so this package doesn't depend on that one and its worker.
+ */
+export type ParsedToolCall = {
+    name: string;
+    args: Record<string, unknown>;
+};
+/** How a model writes tool calls. */
+export type ToolFormat = "lfm2";
+export declare const TOOL_CALL_START = "<|tool_call_start|>";
+export declare const TOOL_CALL_END = "<|tool_call_end|>";
+/** Every tool call in `text`. */
+export declare function parseToolCalls(text: string): Array<ParsedToolCall>;
+/**
+ * Splits a streaming answer into the text before the first tool call (passed
+ * through as it arrives) and the tool-call markup after it (held back and
+ * parsed once the reply ends).
+ */
+export declare function createToolCallSplitter(markers?: Array<string>): {
+    push: (text: string) => string;
+    flush: () => {
+        text: string;
+        markup: string | null;
+    };
+};
+/** A past tool call in LFM2.5's own format, for the assistant turn's text. */
+export declare function formatLfm2ToolCalls(calls: Array<ParsedToolCall>): string;
+//# sourceMappingURL=tool-calls.d.ts.map

package/dist/tool-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-calls.d.ts","sourceRoot":"","sources":["../src/tool-calls.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAA;AAE5E,qCAAqC;AACrC,MAAM,MAAM,UAAU,GAAG,MAAM,CAAA;AAE/B,eAAO,MAAM,eAAe,wBAAwB,CAAA;AACpD,eAAO,MAAM,aAAa,sBAAsB,CAAA;AA+GhD,iCAAiC;AACjC,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC,cAAc,CAAC,CAQlE;AAWD;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,GAAE,KAAK,CAAC,MAAM,CAAqB;iBAMtB,MAAM;;;;;EA6B3B;AAUD,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,UAU/D"}

package/dist/tool-calls.js

@@ -0,0 +1,203 @@
+/**
+ * Reading and writing tool calls the way LFM2 and LFM2.5 write them:
+ * Pythonic calls between markers,
+ * `<|tool_call_start|>[get_weather(city="Tokyo")]<|tool_call_end|>`.
+ *
+ * Copied from @tanstack-ai-browser/transformers-js (tool-calls.ts, its LFM2
+ * parts), so this package doesn't depend on that one and its worker.
+ */
+export const TOOL_CALL_START = "<|tool_call_start|>";
+export const TOOL_CALL_END = "<|tool_call_end|>";
+/** A Python-style or JSON value: "x", 'x', 1.5, True, None, [1, 2]… */
+function parseValue(raw) {
+    const s = raw.trim();
+    if (/^(["']).*\1$/s.test(s)) {
+        try {
+            return JSON.parse(s[0] === "'" ? `"${s.slice(1, -1)}"` : s);
+        }
+        catch {
+            return s.slice(1, -1);
+        }
+    }
+    if (s === "True" || s === "true")
+        return true;
+    if (s === "False" || s === "false")
+        return false;
+    if (s === "None" || s === "null")
+        return null;
+    if (s !== "" && !Number.isNaN(Number(s)))
+        return Number(s);
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
+/** After a value: the next argument (`, name=`), or the end of the call. */
+const VALUE_END = /^\s*(?:,\s*[A-Za-z_]\w*\s*=|,?\s*\)|$)/;
+/**
+ * Where the string starting at `body[start]` ends (the index of its closing
+ * quote). The model doesn't escape quotes inside its strings ('JWST's
+ * findings'), so a quote only closes the string when the argument ends
+ * after it; otherwise it's part of the text.
+ */
+function stringEnd(body, start) {
+    const quote = body[start];
+    let last = -1;
+    for (let i = start + 1; i < body.length; i++) {
+        if (body[i] === "\\")
+            i++;
+        else if (body[i] === quote) {
+            if (VALUE_END.test(body.slice(i + 1)))
+                return i;
+            last = i;
+        }
+    }
+    return last;
+}
+/** A Python string literal's text, `\'` and `\"` included. */
+function stringText(raw) {
+    const inner = raw.slice(1, -1);
+    try {
+        const escaped = inner.replace(/\\'/g, "'").replace(/(^|[^\\])"/g, '$1\\"');
+        return JSON.parse(`"${escaped}"`);
+    }
+    catch {
+        return inner;
+    }
+}
+/** Where a `[…]` or `{…}` starting at `body[start]` ends, strings skipped. */
+function bracketEnd(body, start) {
+    let depth = 0;
+    for (let i = start; i < body.length; i++) {
+        const c = body[i];
+        if (c === '"' || c === "'") {
+            const end = stringEnd(body, i);
+            if (end < 0)
+                return -1;
+            i = end;
+        }
+        else if (c === "[" || c === "{")
+            depth++;
+        else if ((c === "]" || c === "}") && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+/** `[name(a="x", b=2), other()]` → calls. */
+function parsePythonic(body) {
+    const calls = [];
+    const callStart = /([A-Za-z_][\w.-]*)\(/g;
+    let m;
+    while ((m = callStart.exec(body))) {
+        const args = {};
+        let i = m.index + m[0].length;
+        for (;;) {
+            const key = /^\s*([A-Za-z_]\w*)\s*=\s*/.exec(body.slice(i));
+            if (!key)
+                break;
+            i += key[0].length;
+            const first = body[i];
+            let end;
+            if (first === '"' || first === "'") {
+                end = stringEnd(body, i);
+                if (end < 0)
+                    break;
+                args[key[1]] = stringText(body.slice(i, end + 1));
+            }
+            else if (first === "[" || first === "{") {
+                end = bracketEnd(body, i);
+                if (end < 0)
+                    break;
+                args[key[1]] = parseValue(body.slice(i, end + 1));
+            }
+            else {
+                const rest = /^[^,)]*/.exec(body.slice(i))?.[0] ?? "";
+                end = i + rest.length - 1;
+                args[key[1]] = parseValue(rest);
+            }
+            i = end + 1;
+            const comma = /^\s*,/.exec(body.slice(i));
+            if (!comma)
+                break;
+            i += comma[0].length;
+        }
+        calls.push({ name: m[1], args });
+        // The next call starts after this one's closing parenthesis.
+        const close = body.indexOf(")", i);
+        callStart.lastIndex = close < 0 ? body.length : close + 1;
+    }
+    return calls;
+}
+/** Every tool call in `text`. */
+export function parseToolCalls(text) {
+    const calls = [];
+    for (const m of text.matchAll(/<\|tool_call_start\|>([\s\S]*?)(?:<\|tool_call_end\|>|$)/g)) {
+        calls.push(...parsePythonic(m[1]));
+    }
+    return calls;
+}
+/** Length of the longest end of `text` that could start one of `markers`. */
+function partialMarker(text, markers) {
+    for (let n = Math.min(text.length, 18); n > 0; n--) {
+        const end = text.slice(-n);
+        if (markers.some((m) => m.startsWith(end)))
+            return n;
+    }
+    return 0;
+}
+/**
+ * Splits a streaming answer into the text before the first tool call (passed
+ * through as it arrives) and the tool-call markup after it (held back and
+ * parsed once the reply ends).
+ */
+export function createToolCallSplitter(markers = [TOOL_CALL_START]) {
+    let held = "";
+    let markup = null;
+    /** Text that can be shown now. */
+    function push(text) {
+        if (markup !== null) {
+            markup += text;
+            return "";
+        }
+        held += text;
+        const at = Math.min(...markers.map((m) => held.indexOf(m)).filter((i) => i >= 0));
+        if (Number.isFinite(at)) {
+            const before = held.slice(0, at);
+            markup = held.slice(at);
+            held = "";
+            return before;
+        }
+        const keep = partialMarker(held, markers);
+        const out = held.slice(0, held.length - keep);
+        held = held.slice(out.length);
+        return out;
+    }
+    /** The rest of the text, and the tool-call markup if any. */
+    function flush() {
+        const rest = held;
+        held = "";
+        return { text: rest, markup };
+    }
+    return { push, flush };
+}
+/** A value written the way Python (and LFM2.5) writes it. */
+function pythonValue(value) {
+    if (value === true)
+        return "True";
+    if (value === false)
+        return "False";
+    if (value === null || value === undefined)
+        return "None";
+    return JSON.stringify(value);
+}
+/** A past tool call in LFM2.5's own format, for the assistant turn's text. */
+export function formatLfm2ToolCalls(calls) {
+    const list = calls
+        .map((c) => `${c.name}(${Object.entries(c.args)
+        .map(([k, v]) => `${k}=${pythonValue(v)}`)
+        .join(", ")})`)
+        .join(", ");
+    return `${TOOL_CALL_START}[${list}]${TOOL_CALL_END}`;
+}

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@tanstack-ai-browser/wllama",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "TanStack AI adapter for GGUF models running in the browser with wllama (llama.cpp in WebAssembly)",
+  "license": "MIT",
+  "author": "daveycodez",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daveycodez/tanstack-ai-browser.git",
+    "directory": "packages/wllama"
+  },
+  "homepage": "https://github.com/daveycodez/tanstack-ai-browser/tree/main/packages/wllama#readme",
+  "bugs": "https://github.com/daveycodez/tanstack-ai-browser/issues",
+  "keywords": [
+    "tanstack-ai",
+    "tanstack",
+    "ai",
+    "llm",
+    "wllama",
+    "llama.cpp",
+    "gguf",
+    "webassembly",
+    "browser",
+    "local-ai"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@tanstack-ai-browser/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "nx": {
+    "name": "wllama"
+  },
+  "peerDependencies": {
+    "@tanstack/ai": "^1.0.0"
+  },
+  "devDependencies": {
+    "@tanstack/ai": "1.4.0",
+    "esbuild": "0.28.2"
+  },
+  "scripts": {
+    "test": "node --import @swc-node/register/esm-register --test \"src/**/*.test.ts\""
+  },
+  "dependencies": {
+    "@tanstack/openai-base": "^1.0.4",
+    "@wllama/wllama": "3.13.0"
+  }
+}