@tanstack-ai-browser/apfel 0.2.0 → 0.2.2

package/dist/adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAA;AAGjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAErD,MAAM,MAAM,WAAW,GAAG;IACxB,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACxC,CAAA;AAED,mGAAmG;AACnG,MAAM,MAAM,qBAAqB,GAAG;IAClC,+BAA+B;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,cAAc,GAAG,aAAa,GAAG,WAAW,CAAA;AAEvF,iFAAiF;AACjF,MAAM,MAAM,gBAAgB,GAAG,2BAA2B,CAAC,UAAU,EAAE,qBAAqB,CAAC,GAAG;IAC9F,sEAAsE;IACtE,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAAA;IACrE,6EAA6E;IAC7E,YAAY,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IACzD,uFAAuF;IACvF,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACtE,CAAA;AAID,+FAA+F;AAC/F,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAA;AACjE,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAA"}
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAA;AAIjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAErD,MAAM,MAAM,WAAW,GAAG;IACxB,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACxC,CAAA;AAED,mGAAmG;AACnG,MAAM,MAAM,qBAAqB,GAAG;IAClC,+BAA+B;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG,aAAa,GAAG,cAAc,GAAG,aAAa,GAAG,WAAW,CAAA;AAEvF,iFAAiF;AACjF,MAAM,MAAM,gBAAgB,GAAG,2BAA2B,CAAC,UAAU,EAAE,qBAAqB,CAAC,GAAG;IAC9F,sEAAsE;IACtE,QAAQ,CAAC,eAAe,EAAE,aAAa,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,SAAS,CAAA;IACrE,6EAA6E;IAC7E,YAAY,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;IACzD,uFAAuF;IACvF,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAA;CACtE,CAAA;AAID,+FAA+F;AAC/F,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAA;AAEvD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAA;AACjE,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,gBAAgB,CAAA"}

package/dist/adapter.js

@@ -24,6 +24,15 @@ export function apfelText(modelOrConfig, maybeConfig = {}) {
         // apfel runs on the user's own machine: there's no secret key to expose.
         dangerouslyAllowBrowser: true
     });
+    const hooks = adapter;
+    const convert = hooks.chatCompletionsTokenUsage.bind(adapter);
+    hooks.chatCompletionsTokenUsage = (usage, source) => {
+        const result = convert(usage, source);
+        if (!result)
+            return result;
+        const cachedTokens = usage?.prompt_tokens_details?.cached_tokens ?? 0;
+        return { ...result, promptTokensDetails: { ...result.promptTokensDetails, cachedTokens } };
+    };
     const availability = async (signal) => {
         try {
             const timeout = AbortSignal.timeout(10_000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack-ai-browser/apfel",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "TanStack AI adapter for Apple's on-device Foundation Model, served by apfel",
   "license": "MIT",
   "author": "daveycodez",

package/src/adapter.ts

@@ -8,6 +8,7 @@
  */
 import { openaiCompatibleText } from "@tanstack/ai-openai/compatible"
 import type { OpenAICompatibleChatAdapter } from "@tanstack/ai-openai/compatible"
+import type { TokenUsage } from "@tanstack/ai"
 
 import { APFEL_MODEL_META } from "./model-meta.js"
 import type { ApfelChatModel } from "./model-meta.js"
@@ -75,6 +76,19 @@ export function apfelText(modelOrConfig?: ApfelModel | ApfelConfig, maybeConfig:
     dangerouslyAllowBrowser: true
   }) as OpenAICompatibleChatAdapter<ApfelModel, ApfelTextModelOptions>
 
+  // apfel answers each request from a new session holding its messages, so
+  // the whole prompt is read every time, and nothing is cached (apfel reports
+  // no count): cachedTokens 0, unless apfel counts some itself.
+  type Usage = (usage: { prompt_tokens_details?: { cached_tokens?: number } | null } | null | undefined, source?: unknown) => TokenUsage | undefined
+  const hooks = adapter as unknown as { chatCompletionsTokenUsage: Usage }
+  const convert = hooks.chatCompletionsTokenUsage.bind(adapter)
+  hooks.chatCompletionsTokenUsage = (usage, source) => {
+    const result = convert(usage, source)
+    if (!result) return result
+    const cachedTokens = usage?.prompt_tokens_details?.cached_tokens ?? 0
+    return { ...result, promptTokensDetails: { ...result.promptTokensDetails, cachedTokens } }
+  }
+
   const availability = async (signal?: AbortSignal): Promise<Availability> => {
     try {
       const timeout = AbortSignal.timeout(10_000)

package/dist/guided-schema.d.ts

@@ -1,20 +0,0 @@
-/**
- * Tool schemas in the subset of JSON Schema that apfel's guided generation
- * enforces, for the tool step's arguments (see adapter.ts, `stepSchema`).
- * apfel rejects the keywords it can't enforce with HTTP 400.
- */
-type JsonSchema = Record<string, unknown>;
-/**
- * The schema in the subset guided generation enforces: types, properties,
- * required, items, enum, const and descriptions. Local `$ref`s are inlined,
- * `anyOf`/`oneOf`/type unions become their first non-null choice, and
- * constraints it can't enforce (lengths, patterns, formats…) are dropped.
- */
-export declare function toGuidedSchema(schema: unknown, root?: JsonSchema, depth?: number): JsonSchema;
-/**
- * Arguments written under `toGuidedSchema`, without the nulls it allows in
- * optional fields: a null is a field the model left out.
- */
-export declare function withoutNulls(value: unknown, schema: JsonSchema): unknown;
-export {};
-//# sourceMappingURL=guided-schema.d.ts.map

package/dist/guided-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"guided-schema.d.ts","sourceRoot":"","sources":["../src/guided-schema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAoBzC;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,OAAO,EACf,IAAI,GAAE,UAA2C,EACjD,KAAK,SAAI,GACR,UAAU,CA4EZ;AA2BD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAuBxE"}

package/dist/guided-schema.js

@@ -1,136 +0,0 @@
-/**
- * Tool schemas in the subset of JSON Schema that apfel's guided generation
- * enforces, for the tool step's arguments (see adapter.ts, `stepSchema`).
- * apfel rejects the keywords it can't enforce with HTTP 400.
- */
-/** Keywords guided generation can enforce; apfel rejects others with 400. */
-const KEPT = ["type", "description", "enum", "const"];
-const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-/** The schema a local `$ref` (`#/$defs/X`, `#/definitions/X`) points to. */
-function resolveRef(ref, root) {
-    if (!ref.startsWith("#/"))
-        return undefined;
-    let node = root;
-    for (const key of ref.slice(2).split("/")) {
-        node = isObject(node)
-            ? node[key.replace(/~1/g, "/").replace(/~0/g, "~")]
-            : undefined;
-    }
-    return isObject(node) ? node : undefined;
-}
-/**
- * The schema in the subset guided generation enforces: types, properties,
- * required, items, enum, const and descriptions. Local `$ref`s are inlined,
- * `anyOf`/`oneOf`/type unions become their first non-null choice, and
- * constraints it can't enforce (lengths, patterns, formats…) are dropped.
- */
-export function toGuidedSchema(schema, root = isObject(schema) ? schema : {}, depth = 0) {
-    if (!isObject(schema) || depth > 12)
-        return { type: "string" };
-    if (typeof schema.$ref === "string") {
-        const target = resolveRef(schema.$ref, root);
-        return target
-            ? toGuidedSchema({ ...target, ...withoutKey(schema, "$ref") }, root, depth + 1)
-            : { type: "string" };
-    }
-    const choices = (schema.anyOf ?? schema.oneOf);
-    if (Array.isArray(choices)) {
-        const choice = choices.find((c) => isObject(c) && c.type !== "null") ?? choices[0];
-        return toGuidedSchema({
-            ...(isObject(choice) ? choice : {}),
-            ...(schema.description !== undefined && {
-                description: schema.description
-            })
-        }, root, depth + 1);
-    }
-    if (Array.isArray(schema.allOf)) {
-        const merged = schema.allOf.reduce((all, part) => (isObject(part) ? mergeSchemas(all, part) : all), withoutKey(schema, "allOf"));
-        return toGuidedSchema(merged, root, depth + 1);
-    }
-    const out = {};
-    for (const key of KEPT) {
-        if (schema[key] !== undefined)
-            out[key] = schema[key];
-    }
-    if (Array.isArray(out.type)) {
-        out.type = out.type.find((t) => t !== "null") ?? "string";
-    }
-    if (out.type === undefined) {
-        if (isObject(schema.properties))
-            out.type = "object";
-        else if (schema.items !== undefined)
-            out.type = "array";
-        else if (Array.isArray(out.enum))
-            out.type = typeof out.enum[0];
-        else if (out.const === undefined)
-            out.type = "string";
-    }
-    if (out.type === "object") {
-        const properties = isObject(schema.properties) ? schema.properties : {};
-        out.properties = Object.fromEntries(Object.entries(properties).map(([key, value]) => [
-            key,
-            toGuidedSchema(value, root, depth + 1)
-        ]));
-        out.required = Array.isArray(schema.required)
-            ? schema.required.filter((key) => typeof key === "string" && key in properties)
-            : [];
-        // An optional field can also be null, as in the Prompt API adapter
-        // (Gemini Nano wrote 0 for coordinates it didn't have). apfel reads a
-        // nullable field as optional, and takes only strings in an enum, so an
-        // enum gets no null of its own. `withoutNulls` drops any null written.
-        const required = new Set(out.required);
-        for (const [key, value] of Object.entries(out.properties)) {
-            if (!required.has(key))
-                value.type = [value.type, "null"];
-        }
-    }
-    if (out.type === "array") {
-        out.items = toGuidedSchema(schema.items ?? {}, root, depth + 1);
-    }
-    return out;
-}
-function withoutKey(schema, key) {
-    const rest = { ...schema };
-    delete rest[key];
-    return rest;
-}
-function mergeSchemas(a, b) {
-    const merged = { ...a, ...b };
-    if (isObject(a.properties) || isObject(b.properties)) {
-        merged.properties = {
-            ...(isObject(a.properties) ? a.properties : {}),
-            ...(isObject(b.properties) ? b.properties : {})
-        };
-    }
-    if (Array.isArray(a.required) || Array.isArray(b.required)) {
-        merged.required = [
-            ...new Set([
-                ...(Array.isArray(a.required) ? a.required : []),
-                ...(Array.isArray(b.required) ? b.required : [])
-            ])
-        ];
-    }
-    return merged;
-}
-/**
- * Arguments written under `toGuidedSchema`, without the nulls it allows in
- * optional fields: a null is a field the model left out.
- */
-export function withoutNulls(value, schema) {
-    if (Array.isArray(value)) {
-        const items = isObject(schema.items) ? schema.items : {};
-        return value.map((item) => withoutNulls(item, items));
-    }
-    if (!isObject(value))
-        return value;
-    const properties = isObject(schema.properties) ? schema.properties : {};
-    const required = Array.isArray(schema.required) ? schema.required : [];
-    return Object.fromEntries(Object.entries(value).flatMap(([key, field]) => field === null && !required.includes(key)
-        ? []
-        : [
-            [
-                key,
-                withoutNulls(field, isObject(properties[key]) ? properties[key] : {})
-            ]
-        ]));
-}

package/dist/tool-calls.d.ts

@@ -1,32 +0,0 @@
-/**
- * Tool calls Apple's model writes as text. apfel turns the model's tool
- * calls into OpenAI `tool_calls`, but when it doesn't recognize one it
- * passes it on as text instead, like
- * `{"tool_calls": [{"function": "get_weather", "arguments": {…}}]}`.
- */
-export type ParsedToolCall = {
-    name: string;
-    args: Record<string, unknown>;
-};
-/** Where Apple's model starts a tool call it writes as text. */
-export declare const JSON_TOOL_CALLS_MARKER = "{\"tool_calls\"";
-/**
- * Tool calls Apple's model wrote as JSON text. Its JSON varies and is often
- * broken (`"function": "name"`, `"name: "name"`, stray strings in the
- * arguments), so instead of parsing the whole thing, this finds each quoted
- * name of a tool that exists and reads the `"arguments"` object after it.
- */
-export declare function parseJsonToolCalls(text: string, toolNames: Iterable<string>): Array<ParsedToolCall>;
-/**
- * Splits a streaming answer into the text before the first tool call written
- * as text (passed through as it arrives) and the tool-call JSON after it
- * (held back and parsed once the reply ends).
- */
-export declare function createToolCallSplitter(marker?: string): {
-    push: (text: string) => string;
-    flush: () => {
-        text: string;
-        markup: string | null;
-    };
-};
-//# sourceMappingURL=tool-calls.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tool-calls.d.ts","sourceRoot":"","sources":["../src/tool-calls.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAA;AAE5E,gEAAgE;AAChE,eAAO,MAAM,sBAAsB,oBAAkB,CAAA;AAkCrD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC1B,KAAK,CAAC,cAAc,CAAC,CAiCvB;AAUD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,SAAyB;iBAKhD,MAAM;;;;;EA2B3B"}

package/dist/tool-calls.js

@@ -1,123 +0,0 @@
-/**
- * Tool calls Apple's model writes as text. apfel turns the model's tool
- * calls into OpenAI `tool_calls`, but when it doesn't recognize one it
- * passes it on as text instead, like
- * `{"tool_calls": [{"function": "get_weather", "arguments": {…}}]}`.
- */
-/** Where Apple's model starts a tool call it writes as text. */
-export const JSON_TOOL_CALLS_MARKER = '{"tool_calls"';
-/** The `{…}` that starts at `text[start]`, braces in strings ignored. */
-function balancedObject(text, start) {
-    let depth = 0;
-    let inString = false;
-    for (let i = start; i < text.length; i++) {
-        const c = text[i];
-        if (inString) {
-            if (c === "\\")
-                i++;
-            else if (c === '"')
-                inString = false;
-        }
-        else if (c === '"')
-            inString = true;
-        else if (c === "{")
-            depth++;
-        else if (c === "}" && --depth === 0)
-            return text.slice(start, i + 1);
-    }
-    return null;
-}
-/** JSON arguments, read leniently: stray strings without a key are dropped. */
-function parseJsonArgs(raw) {
-    for (const candidate of [raw, raw.replace(/,\s*"[^"]*"\s*(?=[,}])/g, "")]) {
-        try {
-            const value = JSON.parse(candidate);
-            const args = typeof value === "string" ? JSON.parse(value) : value;
-            if (args && typeof args === "object") {
-                return args;
-            }
-        }
-        catch {
-            // Try the next reading.
-        }
-    }
-    return null;
-}
-/**
- * Tool calls Apple's model wrote as JSON text. Its JSON varies and is often
- * broken (`"function": "name"`, `"name: "name"`, stray strings in the
- * arguments), so instead of parsing the whole thing, this finds each quoted
- * name of a tool that exists and reads the `"arguments"` object after it.
- */
-export function parseJsonToolCalls(text, toolNames) {
-    const mentions = [];
-    for (const name of toolNames) {
-        const quoted = `"${name}"`;
-        for (let at = text.indexOf(quoted); at >= 0; at = text.indexOf(quoted, at + 1)) {
-            mentions.push({ name, at });
-        }
-    }
-    mentions.sort((a, b) => a.at - b.at);
-    const calls = [];
-    mentions.forEach(({ name, at }, i) => {
-        // The arguments belong to the last mention of a name before them. The
-        // model sometimes writes a broken "arguments" and then a good one: the
-        // first that reads is used.
-        const part = text.slice(at, mentions[i + 1]?.at ?? text.length);
-        for (const key of part.matchAll(/"arguments"?\s*:\s*/g)) {
-            const from = key.index + key[0].length;
-            const raw = part[from] === "{"
-                ? balancedObject(part, from)
-                : /^"(?:[^"\\]|\\.)*"/.exec(part.slice(from))?.[0];
-            const args = raw ? parseJsonArgs(raw) : null;
-            if (args) {
-                calls.push({ name, args });
-                return;
-            }
-        }
-    });
-    return calls;
-}
-/** Length of the longest end of `text` that could start `marker`. */
-function partialMarker(text, marker) {
-    for (let n = Math.min(text.length, marker.length); n > 0; n--) {
-        if (marker.startsWith(text.slice(-n)))
-            return n;
-    }
-    return 0;
-}
-/**
- * Splits a streaming answer into the text before the first tool call written
- * as text (passed through as it arrives) and the tool-call JSON after it
- * (held back and parsed once the reply ends).
- */
-export function createToolCallSplitter(marker = JSON_TOOL_CALLS_MARKER) {
-    let held = "";
-    let markup = null;
-    /** Text that can be shown now. */
-    function push(text) {
-        if (markup !== null) {
-            markup += text;
-            return "";
-        }
-        held += text;
-        const at = held.indexOf(marker);
-        if (at >= 0) {
-            const before = held.slice(0, at);
-            markup = held.slice(at);
-            held = "";
-            return before;
-        }
-        const keep = partialMarker(held, marker);
-        const out = held.slice(0, held.length - keep);
-        held = held.slice(out.length);
-        return out;
-    }
-    /** The rest of the text, and the tool-call JSON if any. */
-    function flush() {
-        const rest = held;
-        held = "";
-        return { text: rest, markup };
-    }
-    return { push, flush };
-}

package/dist/tool-repair.d.ts

@@ -1,56 +0,0 @@
-/**
- * Tool-call repair. Apple's model picks the right tool but often gets its
- * arguments wrong: it renames fields (`limit` for `numResults`, `site` for
- * `includeDomains`) and drops optional ones it was asked to set. So after the
- * model calls a tool, its arguments are written again with apfel's guided
- * generation, which holds the model to the tool's JSON Schema:
- *
- * 1. For each optional field, a yes/no answer: does the request give it a
- *    value? (Asked for the arguments directly, the model leaves out optional
- *    numbers and arrays even when the request states them.)
- * 2. The arguments, with the fields from step 1 required and the rest left
- *    out. Fields the model already got right (schema name, right type) are
- *    kept as it wrote them.
- *
- * Works from the schema alone, for any tool, MCP tools included. Through
- * `chat()` with search, calendar, file and weather tools, the calls came out
- * right 27 times in 32 with this, against 18 without; the misses left are
- * the model not calling a tool at all, which this can't fix.
- */
-type JsonSchema = Record<string, unknown>;
-/**
- * The schema in the subset guided generation enforces: types, properties,
- * required, items, enum, const and descriptions. Local `$ref`s are inlined,
- * `anyOf`/`oneOf`/type unions become their first non-null choice, and
- * constraints it can't enforce (lengths, patterns, formats…) are dropped.
- */
-export declare function toGuidedSchema(schema: unknown, root?: JsonSchema, depth?: number): JsonSchema;
-/**
- * The name of the tool the model meant, when it got the name slightly wrong
- * (case, `-` for `_`…). Undefined if no tool matches.
- */
-export declare function matchToolName(name: string, toolNames: Iterable<string>): string | undefined;
-/** A chat completion request apfel answers with JSON matching `schema`. */
-export type GuidedRequest = {
-    /** Instructions, sent before the conversation. */
-    instructions: string;
-    schema: JsonSchema;
-    name: string;
-};
-/** Sends a guided request; resolves to the model's JSON, parsed. */
-export type GuidedComplete = (request: GuidedRequest) => Promise<unknown>;
-export type RepairableTool = {
-    name: string;
-    description: string;
-    inputSchema?: unknown;
-};
-/**
- * The tool call's arguments, written again under the tool's schema.
- * Undefined if the tool takes no arguments or its schema isn't an object
- * (the model's own arguments are used then).
- */
-export declare function repairToolArguments(tool: RepairableTool, complete: GuidedComplete, 
-/** The model's own arguments, which may use the wrong field names. */
-draft?: string): Promise<Record<string, unknown> | undefined>;
-export {};
-//# sourceMappingURL=tool-repair.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tool-repair.d.ts","sourceRoot":"","sources":["../src/tool-repair.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAoBzC;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,OAAO,EACf,IAAI,GAAE,UAA2C,EACjD,KAAK,SAAI,GACR,UAAU,CAkEZ;AA4FD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,sBAMtE;AAED,2EAA2E;AAC3E,MAAM,MAAM,aAAa,GAAG;IAC1B,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,UAAU,CAAA;IAClB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAEzE,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,cAAc;AACxB,sEAAsE;AACtE,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAyE9C"}

package/dist/tool-repair.js

@@ -1,252 +0,0 @@
-/**
- * Tool-call repair. Apple's model picks the right tool but often gets its
- * arguments wrong: it renames fields (`limit` for `numResults`, `site` for
- * `includeDomains`) and drops optional ones it was asked to set. So after the
- * model calls a tool, its arguments are written again with apfel's guided
- * generation, which holds the model to the tool's JSON Schema:
- *
- * 1. For each optional field, a yes/no answer: does the request give it a
- *    value? (Asked for the arguments directly, the model leaves out optional
- *    numbers and arrays even when the request states them.)
- * 2. The arguments, with the fields from step 1 required and the rest left
- *    out. Fields the model already got right (schema name, right type) are
- *    kept as it wrote them.
- *
- * Works from the schema alone, for any tool, MCP tools included. Through
- * `chat()` with search, calendar, file and weather tools, the calls came out
- * right 27 times in 32 with this, against 18 without; the misses left are
- * the model not calling a tool at all, which this can't fix.
- */
-/** Keywords guided generation can enforce; apfel rejects others with 400. */
-const KEPT = ["type", "description", "enum", "const"];
-const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-/** The schema a local `$ref` (`#/$defs/X`, `#/definitions/X`) points to. */
-function resolveRef(ref, root) {
-    if (!ref.startsWith("#/"))
-        return undefined;
-    let node = root;
-    for (const key of ref.slice(2).split("/")) {
-        node = isObject(node)
-            ? node[key.replace(/~1/g, "/").replace(/~0/g, "~")]
-            : undefined;
-    }
-    return isObject(node) ? node : undefined;
-}
-/**
- * The schema in the subset guided generation enforces: types, properties,
- * required, items, enum, const and descriptions. Local `$ref`s are inlined,
- * `anyOf`/`oneOf`/type unions become their first non-null choice, and
- * constraints it can't enforce (lengths, patterns, formats…) are dropped.
- */
-export function toGuidedSchema(schema, root = isObject(schema) ? schema : {}, depth = 0) {
-    if (!isObject(schema) || depth > 12)
-        return { type: "string" };
-    if (typeof schema.$ref === "string") {
-        const target = resolveRef(schema.$ref, root);
-        return target
-            ? toGuidedSchema({ ...target, ...withoutKey(schema, "$ref") }, root, depth + 1)
-            : { type: "string" };
-    }
-    const choices = (schema.anyOf ?? schema.oneOf);
-    if (Array.isArray(choices)) {
-        const choice = choices.find((c) => isObject(c) && c.type !== "null") ?? choices[0];
-        return toGuidedSchema({
-            ...(isObject(choice) ? choice : {}),
-            ...(schema.description !== undefined && {
-                description: schema.description
-            })
-        }, root, depth + 1);
-    }
-    if (Array.isArray(schema.allOf)) {
-        const merged = schema.allOf.reduce((all, part) => (isObject(part) ? mergeSchemas(all, part) : all), withoutKey(schema, "allOf"));
-        return toGuidedSchema(merged, root, depth + 1);
-    }
-    const out = {};
-    for (const key of KEPT) {
-        if (schema[key] !== undefined)
-            out[key] = schema[key];
-    }
-    if (Array.isArray(out.type)) {
-        out.type = out.type.find((t) => t !== "null") ?? "string";
-    }
-    if (out.type === undefined) {
-        if (isObject(schema.properties))
-            out.type = "object";
-        else if (schema.items !== undefined)
-            out.type = "array";
-        else if (Array.isArray(out.enum))
-            out.type = typeof out.enum[0];
-        else if (out.const === undefined)
-            out.type = "string";
-    }
-    if (out.type === "object") {
-        const properties = isObject(schema.properties) ? schema.properties : {};
-        out.properties = Object.fromEntries(Object.entries(properties).map(([key, value]) => [
-            key,
-            toGuidedSchema(value, root, depth + 1)
-        ]));
-        out.required = Array.isArray(schema.required)
-            ? schema.required.filter((key) => typeof key === "string" && key in properties)
-            : [];
-    }
-    if (out.type === "array") {
-        out.items = toGuidedSchema(schema.items ?? {}, root, depth + 1);
-    }
-    return out;
-}
-function withoutKey(schema, key) {
-    const rest = { ...schema };
-    delete rest[key];
-    return rest;
-}
-function mergeSchemas(a, b) {
-    const merged = { ...a, ...b };
-    if (isObject(a.properties) || isObject(b.properties)) {
-        merged.properties = {
-            ...(isObject(a.properties) ? a.properties : {}),
-            ...(isObject(b.properties) ? b.properties : {})
-        };
-    }
-    if (Array.isArray(a.required) || Array.isArray(b.required)) {
-        merged.required = [
-            ...new Set([
-                ...(Array.isArray(a.required) ? a.required : []),
-                ...(Array.isArray(b.required) ? b.required : [])
-            ])
-        ];
-    }
-    return merged;
-}
-/** Whether `value` fits a guided schema's type and choices. */
-function fits(value, schema) {
-    if (Array.isArray(schema.enum) && !schema.enum.includes(value))
-        return false;
-    if (schema.const !== undefined)
-        return value === schema.const;
-    switch (schema.type) {
-        case "string":
-            return typeof value === "string";
-        case "integer":
-            return Number.isInteger(value);
-        case "number":
-            return typeof value === "number" && Number.isFinite(value);
-        case "boolean":
-            return typeof value === "boolean";
-        case "array":
-            return (Array.isArray(value) &&
-                value.every((item) => fits(item, (schema.items ?? {}))));
-        case "object":
-            return isObject(value);
-        default:
-            return true;
-    }
-}
-/**
- * The fields of the model's own arguments that already have a schema's
- * name and a value of the right type. They're kept as they are: with several
- * calls to one tool in a reply, they're what tells the calls apart.
- */
-function validDraftFields(draft, properties) {
-    let parsed;
-    try {
-        parsed = draft ? JSON.parse(draft) : undefined;
-    }
-    catch {
-        return {};
-    }
-    if (!isObject(parsed))
-        return {};
-    return Object.fromEntries(Object.entries(parsed).filter(([key, value]) => Object.hasOwn(properties, key) &&
-        value !== null &&
-        fits(value, properties[key])));
-}
-/** One line per field: name, type or choices, and description. */
-function describeFields(properties) {
-    return Object.entries(properties)
-        .map(([key, field]) => {
-        const kind = Array.isArray(field.enum)
-            ? field.enum.map((v) => JSON.stringify(v)).join(" | ")
-            : String(field.type ?? "any");
-        const about = typeof field.description === "string" ? `: ${field.description}` : "";
-        return `- ${key} (${kind})${about}`;
-    })
-        .join("\n");
-}
-/**
- * The name of the tool the model meant, when it got the name slightly wrong
- * (case, `-` for `_`…). Undefined if no tool matches.
- */
-export function matchToolName(name, toolNames) {
-    const names = [...toolNames];
-    if (names.includes(name))
-        return name;
-    const plain = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
-    const matches = names.filter((n) => plain(n) === plain(name));
-    return matches.length === 1 ? matches[0] : undefined;
-}
-/**
- * The tool call's arguments, written again under the tool's schema.
- * Undefined if the tool takes no arguments or its schema isn't an object
- * (the model's own arguments are used then).
- */
-export async function repairToolArguments(tool, complete, 
-/** The model's own arguments, which may use the wrong field names. */
-draft) {
-    const schema = toGuidedSchema(tool.inputSchema);
-    const properties = (schema.properties ?? {});
-    if (schema.type !== "object" || Object.keys(properties).length === 0) {
-        return undefined;
-    }
-    const required = schema.required;
-    const optional = Object.keys(properties).filter((key) => !required.includes(key));
-    const about = `the tool ${tool.name}${tool.description ? ` (${tool.description})` : ""}`;
-    // With several calls in one reply, the draft says which one this is.
-    const attempt = draft && draft !== "{}"
-        ? `\nThe assistant's first attempt at this call, which may use wrong field names: ${draft.slice(0, 1000)}`
-        : "";
-    let chosen = [];
-    if (optional.length > 0) {
-        const answer = await complete({
-            name: "fields",
-            instructions: `You are deciding the arguments of a call to ${about}, for the user's latest request. Its fields:\n${describeFields(properties)}\nFor each optional field, answer true only if the conversation states a value for it, otherwise false.`,
-            schema: {
-                type: "object",
-                properties: Object.fromEntries(optional.map((key) => [
-                    key,
-                    {
-                        type: "boolean",
-                        description: `Does the request state a value for ${key}?`
-                    }
-                ])),
-                required: optional
-            }
-        });
-        if (isObject(answer))
-            chosen = optional.filter((key) => answer[key] === true);
-    }
-    const kept = validDraftFields(draft, properties);
-    const fields = [
-        ...new Set([
-            ...required,
-            ...chosen,
-            ...optional.filter((key) => key in kept)
-        ])
-    ];
-    const args = await complete({
-        name: tool.name,
-        instructions: `Write the arguments for a call to ${about} that does what the user asks in their latest request.${attempt}`,
-        schema: {
-            type: "object",
-            properties: Object.fromEntries(fields.map((key) => [key, properties[key]])),
-            required: fields
-        }
-    });
-    if (!isObject(args))
-        return undefined;
-    // Optional fields left empty weren't really set.
-    const written = Object.fromEntries(Object.entries(args).filter(([key, value]) => required.includes(key) ||
-        !(value === "" ||
-            value === null ||
-            (Array.isArray(value) && value.length === 0))));
-    return { ...written, ...kept };
-}

package/dist/tools.d.ts

@@ -1,68 +0,0 @@
-/**
- * Tool calls by prompt, a copy of the Prompt API adapter's
- * (`@tanstack-ai-browser/prompt-api`'s `tools.ts`): keep the two
- * identical. Apple's model writes malformed
- * native tool calls that apfel can't parse, so the system prompt lists the
- * tools as JSON and asks for a call as JSON in a ```tool_call fence; results
- * go back in a ```tool_result fence. The adapter reads calls out of the
- * streamed text.
- */
-import type { ModelMessage, Tool } from "@tanstack/ai";
-/** A tool call read from the model's text. */
-export type ParsedToolCall = {
-    name: string;
-    arguments: Record<string, unknown>;
-};
-/**
- * The system prompt with the tools and how to call them; unchanged without
- * tools.
- */
-export declare function toolSystemPrompt(system: string, tools: ReadonlyArray<Tool>): string;
-/** Earlier tool calls in the conversation, as the model would have written them. */
-export declare function toolCallFence(calls: NonNullable<ModelMessage["toolCalls"]>): string;
-/** A tool's result line for a ```tool_result fence. */
-export declare function toolResultLine(id: string, name: string, content: string, error?: string): string;
-/** Tool results as the model reads them. */
-export declare const toolResultFence: (lines: ReadonlyArray<string>) => string;
-/**
- * The first tool call in a fence's body: a JSON object (or an array of them,
- * or one per line) with `name` (or `tool`, `tool_name`) and `arguments` (or
- * `parameters`), the arguments possibly a JSON string, maybe wrapped in a
- * `tool_call` or `function` key; or a Python-style call, `[name(key="v")]`;
- * or `call:name{key:value}`.
- */
-export declare function parseToolCall(body: string): ParsedToolCall | undefined;
-/**
- * Reads a streamed reply: `push` each piece and get back the text that can
- * be shown now; text inside a ```tool_call fence (or another call's
- * delimiters: `<tool_call>`, `<|tool_call>`, `<|tool_call_start|>`, or a
- * Python-style `[name(…)]`) is held back. The first
- * fence that closes ends the reply (stop generating then): `fence` is its
- * text, `call` the call in it, if it holds one (else the fence is a failed
- * call, for `repairToolCall`), and `trailing` the text after it. Other code
- * fences are text. `end` gives the rest, reading an unclosed fence as the
- * reply's last.
- */
-export declare function toolCallReader(): {
-    readonly call: ParsedToolCall | undefined;
-    readonly fence: string | undefined;
-    /** Text that came after the fence: shown after the call. */
-    readonly trailing: string;
-    push(piece: string): string;
-    end(): string;
-};
-/** Why a call doesn't fit the tools (an unknown tool, or arguments that fail its schema), if it doesn't. */
-export declare function invalidToolCall(call: ParsedToolCall, tools: ReadonlyArray<Tool>): string | undefined;
-/** Why a reply's ```tool_call fence isn't a valid call, if it isn't. */
-export declare const toolCallError: (call: ParsedToolCall | undefined, tools: ReadonlyArray<Tool>) => string | undefined;
-/** The message after a failed call, asking for it again. */
-export declare const repairPrompt: (reason: string) => string;
-/**
- * One repair of a failed tool call, with output held to a schema (as webgllm
- * repairs): the tool's arguments if `name` is a tool, else first the tool's
- * name, then its arguments. `generate(schema)` asks the model, with the
- * conversation, its failed attempt and `repairPrompt`, for JSON that fits
- * `schema`, and returns it parsed. Undefined if the repair fails too.
- */
-export declare function repairToolCall(tools: ReadonlyArray<Tool>, name: string | undefined, generate: (schema: Record<string, unknown>) => Promise<unknown>): Promise<ParsedToolCall | undefined>;
-//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAEtD,8CAA8C;AAC9C,MAAM,MAAM,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAAA;AAiBjF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,MAAM,CAiCnF;AAED,oFAAoF;AACpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC,GAAG,MAAM,CAWnF;AAED,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAUhG;AAED,4CAA4C;AAC5C,eAAO,MAAM,eAAe,UAAW,aAAa,CAAC,MAAM,CAAC,WAAqD,CAAA;AAEjH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CA0CtE;AAyHD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc;aA4CtB,IAAI;aAGJ,KAAK;IAGT,4DAA4D;aACxD,QAAQ;IAGZ,IAAI,QAAQ,MAAM,GAAG,MAAM;IAI3B,GAAG,IAAI,MAAM;EAkBhB;AA2DD,4GAA4G;AAC5G,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,GACzB,MAAM,GAAG,SAAS,CAKpB;AAED,wEAAwE;AACxE,eAAO,MAAM,aAAa,SAClB,cAAc,GAAG,SAAS,SACzB,aAAa,CAAC,IAAI,CAAC,uBAIsB,CAAA;AAElD,4DAA4D;AAC5D,eAAO,MAAM,YAAY,WAAY,MAAM,WACgB,CAAA;AAE3D;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,EAC1B,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,GAC9D,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CA2BrC"}

package/dist/tools.js

@@ -1,469 +0,0 @@
-const DELIMITERS = [
-    { start: "```tool_call", end: "```" },
-    { start: "```tool-call", end: "```" },
-    { start: "<tool_call>", end: "</tool_call>" },
-    { start: "<|tool_call>", end: "<tool_call|>" },
-    { start: "<|tool_call_start|>", end: "<|tool_call_end|>" }
-];
-/** A Python-style call, `[name(...)]`. */
-const PYTHON_CALL = /\[(\w+)\(/;
-const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-/**
- * The system prompt with the tools and how to call them; unchanged without
- * tools.
- */
-export function toolSystemPrompt(system, tools) {
-    if (tools.length === 0)
-        return system;
-    const definitions = tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description ?? "No description provided.",
-        parameters: tool.inputSchema ?? { type: "object", properties: {} }
-    }));
-    const instructions = `You are a helpful AI assistant with access to tools.
-
-# Available Tools
-${JSON.stringify(definitions, null, 2)}
-
-# Tool Calling Instructions
-Only request one tool call at a time. Wait for tool results before asking for another tool.
-
-To call a tool, output JSON in this exact format inside a \`\`\`tool_call code fence:
-
-\`\`\`tool_call
-{"name": "tool_name", "arguments": {"param1": "value1", "param2": "value2"}}
-\`\`\`
-
-Tool responses will be provided in \`\`\`tool_result fences. Each line contains JSON like:
-\`\`\`tool_result
-{"id": "call_123", "name": "tool_name", "result": {...}, "error": false}
-\`\`\`
-Use the \`result\` payload (and treat \`error\` as a boolean flag) when continuing the conversation.
-
-Important:
-- Use exact tool and parameter names from the schema above
-- Arguments must be a valid JSON object matching the tool's parameters
-- You can include brief reasoning before or after the tool call
-- If no tool is needed, respond directly without tool_call fences`;
-    return system.trim() ? `${system.trim()}\n\n${instructions}` : instructions;
-}
-/** Earlier tool calls in the conversation, as the model would have written them. */
-export function toolCallFence(calls) {
-    const lines = calls.map((call) => {
-        let args;
-        try {
-            args = JSON.parse(call.function.arguments || "{}");
-        }
-        catch {
-            args = call.function.arguments;
-        }
-        return JSON.stringify({ name: call.function.name, arguments: args, ...(call.id && { id: call.id }) });
-    });
-    return `\`\`\`tool_call\n${lines.join("\n")}\n\`\`\``;
-}
-/** A tool's result line for a ```tool_result fence. */
-export function toolResultLine(id, name, content, error) {
-    let result = error ?? content;
-    if (error === undefined) {
-        try {
-            result = JSON.parse(content);
-        }
-        catch {
-            // Plain text.
-        }
-    }
-    return JSON.stringify({ name, result: result ?? null, error: error !== undefined, ...(id && { id }) });
-}
-/** Tool results as the model reads them. */
-export const toolResultFence = (lines) => `\`\`\`tool_result\n${lines.join("\n")}\n\`\`\``;
-/**
- * The first tool call in a fence's body: a JSON object (or an array of them,
- * or one per line) with `name` (or `tool`, `tool_name`) and `arguments` (or
- * `parameters`), the arguments possibly a JSON string, maybe wrapped in a
- * `tool_call` or `function` key; or a Python-style call, `[name(key="v")]`;
- * or `call:name{key:value}`.
- */
-export function parseToolCall(body) {
-    const text = body.trim();
-    // `call:name{key:value,…}`
-    const colon = /call:(\w+)\{([^}]*)\}/.exec(text);
-    if (colon)
-        return { name: colon[1], arguments: parseColonArguments(colon[2]) };
-    // Python style, `[name(key="value")]` or `name(key="value")`
-    if (/^\[?\s*\w+\(/.test(text)) {
-        const call = parsePythonCall(text);
-        if (call)
-            return call;
-    }
-    const candidates = [];
-    try {
-        const value = JSON.parse(text);
-        candidates.push(...(Array.isArray(value) ? value : [value]));
-    }
-    catch {
-        for (const line of text.split("\n")) {
-            try {
-                candidates.push(JSON.parse(line));
-            }
-            catch {
-                // Not JSON.
-            }
-        }
-    }
-    for (const candidate of candidates) {
-        // A call wrapped in a "tool_call" or "function" key is read too.
-        const call = isObject(candidate) && isObject(candidate.tool_call ?? candidate.function)
-            ? (candidate.tool_call ?? candidate.function)
-            : candidate;
-        if (!isObject(call))
-            continue;
-        const name = call.name ?? call.tool ?? call.tool_name;
-        if (typeof name !== "string" || !name)
-            continue;
-        let args = call.arguments ?? call.parameters ?? {};
-        if (typeof args === "string") {
-            try {
-                args = JSON.parse(args);
-            }
-            catch {
-                // Left as is, and rejected below.
-            }
-        }
-        if (isObject(args))
-            return { name, arguments: args };
-    }
-    return undefined;
-}
-/** `key:value,…` pairs, values read as numbers, booleans or null where they are. */
-function parseColonArguments(text) {
-    const args = {};
-    for (const pair of text.split(",")) {
-        const at = pair.indexOf(":");
-        if (at <= 0)
-            continue;
-        const key = pair.slice(0, at).trim();
-        const raw = pair.slice(at + 1).trim();
-        const number = Number(raw);
-        args[key] =
-            raw === "true" ? true : raw === "false" ? false : raw === "null" ? null : raw !== "" && !Number.isNaN(number) ? number : raw;
-    }
-    return args;
-}
-/** The index of the bracket that closes the one at `open`, past quoted text, or -1. */
-function closing(text, open) {
-    const pairs = { "(": ")", "[": "]", "{": "}" };
-    const stack = [];
-    let quote = "";
-    for (let i = open; i < text.length; i++) {
-        const c = text[i];
-        if (quote) {
-            if (c === "\\")
-                i++;
-            else if (c === quote)
-                quote = "";
-        }
-        else if (c === '"' || c === "'")
-            quote = c;
-        else if (pairs[c])
-            stack.push(pairs[c]);
-        else if (c === stack.at(-1)) {
-            stack.pop();
-            if (stack.length === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-/** `text` split at its top-level commas (not inside quotes or brackets). */
-function splitTopLevel(text) {
-    const parts = [];
-    let depth = 0;
-    let quote = "";
-    let from = 0;
-    for (let i = 0; i < text.length; i++) {
-        const c = text[i];
-        if (quote) {
-            if (c === "\\")
-                i++;
-            else if (c === quote)
-                quote = "";
-        }
-        else if (c === '"' || c === "'")
-            quote = c;
-        else if ("([{".includes(c))
-            depth++;
-        else if (")]}".includes(c))
-            depth--;
-        else if (c === "," && depth === 0) {
-            parts.push(text.slice(from, i));
-            from = i + 1;
-        }
-    }
-    parts.push(text.slice(from));
-    return parts.map((part) => part.trim()).filter(Boolean);
-}
-/** A Python literal (string, number, True/False/None, list, dict) as a value. */
-function pythonValue(raw) {
-    const text = raw.trim();
-    if (text === "True")
-        return true;
-    if (text === "False")
-        return false;
-    if (text === "None")
-        return null;
-    if (/^(["']).*\1$/s.test(text))
-        return text.slice(1, -1).replace(/\\(["'\\])/g, "$1");
-    const json = text
-        .replace(/'((?:[^'\\]|\\.)*)'/g, (_, inner) => JSON.stringify(inner.replace(/\\'/g, "'")))
-        .replace(/\bTrue\b/g, "true")
-        .replace(/\bFalse\b/g, "false")
-        .replace(/\bNone\b/g, "null");
-    try {
-        return JSON.parse(json);
-    }
-    catch {
-        return text;
-    }
-}
-/** The first Python-style call in `text`: `name(key=value, …)`, maybe in brackets. */
-function parsePythonCall(text) {
-    const match = /(\w+)\(/.exec(text);
-    if (!match)
-        return undefined;
-    const open = match.index + match[1].length;
-    const close = closing(text, open);
-    if (close === -1)
-        return undefined;
-    const args = {};
-    for (const part of splitTopLevel(text.slice(open + 1, close))) {
-        const at = part.indexOf("=");
-        if (at <= 0)
-            continue;
-        args[part.slice(0, at).trim()] = pythonValue(part.slice(at + 1));
-    }
-    return { name: match[1], arguments: args };
-}
-/** The JSON object `text` starts with, up to its closing brace (or all of `text`). */
-function leadingObject(text) {
-    const start = text.indexOf("{");
-    let depth = 0;
-    let quoted = false;
-    for (let i = start; i >= 0 && i < text.length; i++) {
-        const c = text[i];
-        if (quoted) {
-            if (c === "\\")
-                i++;
-            else if (c === '"')
-                quoted = false;
-        }
-        else if (c === '"')
-            quoted = true;
-        else if (c === "{")
-            depth++;
-        else if (c === "}" && --depth === 0)
-            return text.slice(start, i + 1);
-    }
-    return text;
-}
-/** Characters at the end of `text` that could start a fence. */
-function partialFenceStart(text) {
-    for (let size = Math.min(text.length, Math.max(...DELIMITERS.map((d) => d.start.length)) - 1); size > 0; size--) {
-        const end = text.slice(-size);
-        if (DELIMITERS.some((d) => d.start.startsWith(end)))
-            return size;
-    }
-    return 0;
-}
-/**
- * Reads a streamed reply: `push` each piece and get back the text that can
- * be shown now; text inside a ```tool_call fence (or another call's
- * delimiters: `<tool_call>`, `<|tool_call>`, `<|tool_call_start|>`, or a
- * Python-style `[name(…)]`) is held back. The first
- * fence that closes ends the reply (stop generating then): `fence` is its
- * text, `call` the call in it, if it holds one (else the fence is a failed
- * call, for `repairToolCall`), and `trailing` the text after it. Other code
- * fences are text. `end` gives the rest, reading an unclosed fence as the
- * reply's last.
- */
-export function toolCallReader() {
-    let buffer = "";
-    // The delimiter of the call being read; a Python-style call is read whole.
-    let start;
-    let fence;
-    let call;
-    // Text after the fence, in the piece that closed it.
-    let trailing = "";
-    // A reply that starts with "{" may be a call without its fence (Apple's
-    // model writes one sometimes): held back until the reply ends.
-    let bare;
-    const read = () => {
-        let shown = "";
-        if (fence !== undefined)
-            return shown;
-        if (bare === undefined && buffer.trim())
-            bare = buffer.trimStart().startsWith("{");
-        if (bare)
-            return shown;
-        if (!start) {
-            const python = PYTHON_CALL.exec(buffer);
-            const found = [
-                ...DELIMITERS.map((d) => ({ d, at: buffer.indexOf(d.start) })),
-                ...(python ? [{ d: { start: python[0], end: ")]", python: true }, at: python.index }] : [])
-            ]
-                .filter((f) => f.at !== -1)
-                .sort((a, b) => a.at - b.at)[0];
-            if (!found) {
-                const keep = partialFenceStart(buffer);
-                shown += buffer.slice(0, buffer.length - keep);
-                buffer = buffer.slice(buffer.length - keep);
-                return shown;
-            }
-            shown += buffer.slice(0, found.at);
-            buffer = buffer.slice(found.at);
-            start = found.d;
-        }
-        const close = buffer.indexOf(start.end, start.start.length);
-        if (close === -1)
-            return shown;
-        fence = buffer.slice(0, close + start.end.length);
-        trailing = buffer.slice(fence.length);
-        call = parseToolCall(start.python ? fence : fence.slice(start.start.length, close));
-        return shown;
-    };
-    return {
-        get call() {
-            return call;
-        },
-        get fence() {
-            return fence;
-        },
-        /** Text that came after the fence: shown after the call. */
-        get trailing() {
-            return trailing;
-        },
-        push(piece) {
-            buffer += piece;
-            return read();
-        },
-        end() {
-            if (fence !== undefined)
-                return "";
-            if (start) {
-                fence = buffer;
-                call = parseToolCall(start.python ? buffer : buffer.slice(start.start.length));
-                return "";
-            }
-            const rest = buffer;
-            buffer = "";
-            const bareCall = bare ? parseToolCall(leadingObject(rest)) : undefined;
-            if (bareCall) {
-                fence = rest;
-                call = bareCall;
-                return "";
-            }
-            return rest;
-        }
-    };
-}
-const matches = (type, value) => type === "string"
-    ? typeof value === "string"
-    : type === "number"
-        ? typeof value === "number"
-        : type === "integer"
-            ? Number.isInteger(value)
-            : type === "boolean"
-                ? typeof value === "boolean"
-                : type === "array"
-                    ? Array.isArray(value)
-                    : type === "object"
-                        ? isObject(value)
-                        : type === "null"
-                            ? value === null
-                            : true;
-/** Why `value` doesn't fit `schema` (types, enums, required and unknown fields), if it doesn't. */
-function schemaError(schema, value, path) {
-    if (!isObject(schema))
-        return undefined;
-    if (Array.isArray(schema.enum) &&
-        !schema.enum.some((e) => JSON.stringify(e) === JSON.stringify(value))) {
-        return `${path} must be one of ${JSON.stringify(schema.enum)}`;
-    }
-    const types = [schema.type].flat().filter((t) => t !== undefined);
-    if (types.length > 0 && !types.some((t) => matches(t, value)))
-        return `${path} must be ${types.join(" or ")}`;
-    if (isObject(value)) {
-        const properties = isObject(schema.properties) ? schema.properties : {};
-        for (const key of Array.isArray(schema.required) ? schema.required : []) {
-            if (typeof key === "string" && !(key in value))
-                return `${path}.${key} is missing`;
-        }
-        for (const [key, field] of Object.entries(value)) {
-            if (key in properties) {
-                const error = schemaError(properties[key], field, `${path}.${key}`);
-                if (error)
-                    return error;
-            }
-            else if (schema.additionalProperties === false) {
-                return `${path}.${key} isn't a parameter`;
-            }
-        }
-    }
-    if (Array.isArray(value)) {
-        for (const [i, item] of value.entries()) {
-            const error = schemaError(schema.items, item, `${path}[${i}]`);
-            if (error)
-                return error;
-        }
-    }
-    return undefined;
-}
-/** Why a call doesn't fit the tools (an unknown tool, or arguments that fail its schema), if it doesn't. */
-export function invalidToolCall(call, tools) {
-    const tool = tools.find((t) => t.name === call.name);
-    if (!tool)
-        return `there's no tool named "${call.name}" (the tools are ${tools.map((t) => t.name).join(", ")})`;
-    return schemaError(tool.inputSchema, call.arguments, "arguments");
-}
-/** Why a reply's ```tool_call fence isn't a valid call, if it isn't. */
-export const toolCallError = (call, tools) => call
-    ? invalidToolCall(call, tools)
-    : 'it isn\'t JSON with "name" and "arguments"';
-/** The message after a failed call, asking for it again. */
-export const repairPrompt = (reason) => `That tool call wasn't valid: ${reason}. Write it again.`;
-/**
- * One repair of a failed tool call, with output held to a schema (as webgllm
- * repairs): the tool's arguments if `name` is a tool, else first the tool's
- * name, then its arguments. `generate(schema)` asks the model, with the
- * conversation, its failed attempt and `repairPrompt`, for JSON that fits
- * `schema`, and returns it parsed. Undefined if the repair fails too.
- */
-export async function repairToolCall(tools, name, generate) {
-    if (tools.length === 0)
-        return undefined;
-    try {
-        let tool = tools.find((t) => t.name === name);
-        if (!tool) {
-            const picked = await generate({
-                type: "object",
-                properties: {
-                    name: { type: "string", enum: tools.map((t) => t.name) }
-                },
-                required: ["name"]
-            });
-            tool = tools.find((t) => isObject(picked) && t.name === picked.name);
-            if (!tool)
-                return undefined;
-        }
-        const args = await generate(tool.inputSchema ?? {
-            type: "object",
-            properties: {}
-        });
-        if (!isObject(args))
-            return undefined;
-        const call = { name: tool.name, arguments: args };
-        return invalidToolCall(call, tools) ? undefined : call;
-    }
-    catch {
-        return undefined;
-    }
-}