frontend-agent 1.0.0

package/LICENSE

@@ -0,0 +1,208 @@
+Copyright 2026 The frontend-agent authors
+
+This license (Apache-2.0) covers the source code, scripts, and documentation in
+this repository. It does NOT cover: (a) the fine-tuned model weights, which are a
+derivative of LiquidAI/LFM2.5-230M and remain under the LFM Open License v1.0; or
+(b) the published training dataset, licensed CC-BY-4.0. See README.md.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,95 @@
+# frontend-agent
+
+Drive the **LFM2.5-230M frontend-agent** model in the browser - a tiny, on-device web agent that
+calls real tools and answers grounded in retrieved context. Fully typed, framework-agnostic, loads
+the GGUF from Hugging Face via [wllama](https://github.com/ngxson/wllama) (no server-side inference).
+
+The model is trained for **patterns, not facts**: you supply the tools and the grounding context at
+runtime, and the library reproduces the exact v1.0.0 model contract (system prompt, tool-call format,
+tool-result shapes, and a GBNF grammar that pins tool ids to real search results at decode time).
+
+## Install
+
+```bash
+npm i frontend-agent @wllama/wllama
+npm i minisearch stemmer            # optional: the in-browser RAG adapter (./rag)
+```
+
+## Quickstart
+
+```ts
+import { createAgent, buildRegistry, WllamaEngine, buildSystemPrompt } from 'frontend-agent'
+import { referenceTools } from 'frontend-agent/reference'
+import { LocalMiniSearchRAG } from 'frontend-agent/rag'
+
+const rag = new LocalMiniSearchRAG({ catalog, knowledge })      // your indexed data
+const tools = referenceTools({
+  rag,
+  cart: myCartHandlers,        // add/remove/view/clear over your own state
+  navigate: (target, id) => router.push(pathFor(target, id)),
+})
+const registry = buildRegistry(tools)        // schemas + handlers, what createAgent expects
+
+const engine = new WllamaEngine({
+  // loads https://huggingface.co/lazos/lfm2.5-230m-frontend-agent/resolve/main/...-v1.0.0-Q6_K.gguf
+  model: { repo: 'lazos/lfm2.5-230m-frontend-agent', version: 'v1.0.0', quant: 'Q6_K' },
+  wllamaAssets,                // wllama single/multi-thread WASM URLs
+  onProgress: (p) => {},
+})
+
+const session = createAgent({
+  engine,
+  tools: registry,
+  systemPrompt: () => buildSystemPrompt({ persona, catalogHint: () => rag.hint(6), toolSchemas: registry.schemas }),
+})
+
+session.on((e) => {
+  if (e.type === 'assistant') console.log(e.text)
+})
+
+// one entry point - feed it from a text box, an API, or a speech-to-text transcript:
+await session.submit('do you have any espresso grinders?')
+session.abort()               // cancel an in-flight turn
+```
+
+`submit(text)` is the whole input channel - the library is agnostic to where the text comes from.
+Wire your own source (typed box, an external API, or a speech-to-text engine like Whisper) and call
+`submit` with the resulting text. The demo shows a Whisper → `submit` voice path.
+
+## Model source
+
+`WllamaEngine`'s `model` resolves a Hugging Face GGUF by default:
+`https://huggingface.co/{repo}/resolve/main/{repo-basename}-{version}-{quant}.gguf`. Override any of
+`{ repo, version, quant }`, or pass `modelUrl` to self-host. Cross-origin loading under COOP/COEP
+requires the page to be cross-origin-isolated; the HF `resolve` CDN sends permissive CORS.
+
+## Cross-origin isolation (multi-threading)
+
+wllama runs **multi-threaded** when the page is cross-origin isolated (`SharedArrayBuffer`), and
+**falls back to single-thread** otherwise - slower, but works with no action required. To enable
+threads, make the page cross-origin isolated by either:
+
+- serving it with `Cross-Origin-Opener-Policy: same-origin` + `Cross-Origin-Embedder-Policy:
+  require-corp` (or `credentialless`) headers, or
+- on a static host that can't set headers (e.g. GitHub Pages), registering a COI service worker such
+  as [`coi-serviceworker`](https://github.com/gzuidhof/coi-serviceworker) - the demo does this.
+
+The library deliberately **does not register a service worker** - an SW hijacks your whole origin's
+fetches and is a deployment concern you own. Note: under COEP `require-corp`, the cross-origin HF
+model load needs the response to send CORP or be fetched CORS/credentialless; `coi-serviceworker`'s
+**credentialless** mode handles this (so threads + the HF default compose on Pages).
+
+## Exports
+
+- `.` - core: `createAgent`, `buildRegistry`, `WllamaEngine`, `StubEngine`, `buildSystemPrompt`,
+  `parseToolCalls`, `renderToolCalls`, `buildToolGrammar`, and all types.
+- `./reference` - `referenceTools({ rag, cart, navigate })`: the 7 canonical tools
+  (search_catalog, search_knowledge, add/remove/view/clear cart, navigate) with trained result shapes.
+- `./rag` - `LocalMiniSearchRAG` (in-browser BM25) + `createRagClient` (bring-your-own `POST /search`).
+
+Input is source-agnostic: `session.submit(text)` is the only feed point - connect a text box, an API,
+or a speech-to-text transcript. (The library ships no STT/TTS; the demo shows a Whisper voice path.)
+
+## License
+
+Apache-2.0. The model weights it drives are under the LFM Open License v1.0 (see the model repo).

package/dist/index.d.ts

@@ -0,0 +1,230 @@
+import { T as ToolSchema, a as ToolHandler, b as ToolDefinition } from './types-ChI5DrVS.js';
+import { AssetsPathConfig } from '@wllama/wllama';
+
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string;
+    name?: string;
+}
+interface EngineGenerateResult {
+    /** Plain-text portion of the reply (tool-call markers stripped). */
+    text: string;
+    /** Parsed tool calls, if the model emitted any. */
+    toolCalls: {
+        name: string;
+        args: Record<string, unknown>;
+    }[];
+    /**
+     * The assistant turn exactly as it should be replayed into the next generation's
+     * context - includes the raw <|tool_call_start|>...<|tool_call_end|> markers when the
+     * model called tools, so multi-turn context matches how the model was trained.
+     */
+    raw: string;
+}
+/**
+ * Implemented by both the stub engine and the real wllama engine so useAgentLoop
+ * doesn't need to know which it's driving. `messages` is the full model-format
+ * conversation (including the system message).
+ */
+interface AgentEngine {
+    /** Eagerly download/initialize the model (and detect the backend) at activation time. */
+    load?(): Promise<void>;
+    /**
+     * `grammar` (GBNF) constrains decoding to valid tool-call structure + id-grounding when provided;
+     * the loop rebuilds it each turn from the tool schema and the ids seen in results so far.
+     */
+    generate(messages: ChatMessage[], grammar?: string): Promise<EngineGenerateResult>;
+}
+
+interface ToolRegistry {
+    /** Tool schemas, in order - injected into the system prompt (order is contract-significant). */
+    schemas: ToolSchema[];
+    /** name → handler dispatch map. */
+    handlers: Record<string, ToolHandler>;
+}
+/** Build a registry from a consumer-supplied tool set. Bring your own tools, or use `referenceTools`. */
+declare function buildRegistry(definitions: ToolDefinition[]): ToolRegistry;
+
+interface ToolCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+/** Events emitted while a turn runs. Subscribe with `session.on(...)`. */
+type AgentEvent = {
+    type: 'status';
+    status: 'thinking' | 'ready' | 'aborted' | 'error';
+} | {
+    type: 'assistant';
+    text: string;
+} | {
+    type: 'tool_call';
+    call: ToolCall;
+} | {
+    type: 'tool_result';
+    name: string;
+    result: unknown;
+} | {
+    type: 'done';
+} | {
+    type: 'error';
+    error: unknown;
+};
+interface AgentConfig {
+    engine: AgentEngine;
+    /** The tool set (schemas + handlers). Build with `buildRegistry(referenceTools(...))` or `buildRegistry(yourTools)`. */
+    tools: ToolRegistry;
+    /** The system prompt, or a provider called once per `submit`. */
+    systemPrompt: string | (() => string | Promise<string>);
+    /** Max tool-loop cycles per turn. Default 8 (the longest trained multi-step flow). */
+    maxIterations?: number;
+    /** Arg keys constrained to seen result ids by the grammar. Default `['id']`. */
+    idKeys?: string[];
+    /** History token budget (system prompt excluded). Default derived from N_CTX. */
+    historyBudgetTokens?: number;
+    /**
+     * Per-generation watchdog (ms). Some WASM engines can hang or crash a worker thread without
+     * ever rejecting the in-flight promise (e.g. a trap on a secondary compute thread that leaves
+     * the main thread waiting on a futex forever) - without this, that turn would sit in
+     * 'thinking' indefinitely with no error surfaced. Default 90s; set 0 to disable.
+     */
+    generationTimeoutMs?: number;
+}
+interface SubmitOptions {
+    signal?: AbortSignal;
+}
+interface Session {
+    /**
+     * The single programmatic entry point: feed user text from anywhere - a text box, an external
+     * API, or STT output - and run the tool loop to completion. Emits events as it goes.
+     */
+    submit(text: string, opts?: SubmitOptions): Promise<void>;
+    /** Abort the in-flight turn (best-effort: stops between generations/tool calls). */
+    abort(): void;
+    /** Subscribe to events. Returns an unsubscribe function. */
+    on(listener: (event: AgentEvent) => void): () => void;
+    /** The model-format conversation so far (assistant turns include raw tool-call markers). */
+    readonly history: ChatMessage[];
+    /** Clear the conversation. */
+    reset(): void;
+}
+declare function createAgent(config: AgentConfig): Session;
+
+/** Reference to a GGUF published on the Hugging Face Hub. */
+interface HFModelRef {
+    /** `owner/name`. Default `lazos/lfm2.5-230m-frontend-agent`. */
+    repo?: string;
+    /** Release/version tag embedded in the filename. Default `v1.0.0`. */
+    version?: string;
+    /** Quantization suffix. Default `Q4_K_M`. */
+    quant?: string;
+}
+type EngineStatus = 'idle' | 'downloading' | 'loading' | 'ready';
+interface WllamaEngineConfig {
+    /** Load the GGUF from Hugging Face (default). Ignored if `modelUrl` is set. */
+    model?: HFModelRef;
+    /** Full GGUF URL - self-host escape hatch; overrides `model`. */
+    modelUrl?: string;
+    /** wllama WASM asset config, e.g. `{ 'single-thread/wllama.wasm': url, 'multi-thread/wllama.wasm': url }`. */
+    wllamaAssets: AssetsPathConfig;
+    /** Context window. Default 8192. */
+    nCtx?: number;
+    /** Max tokens per assistant turn. Default 320. */
+    maxTokens?: number;
+    /** Backend preference. `'auto'` uses WebGPU when a real adapter is present. Default `'auto'`. */
+    backend?: 'auto' | 'webgpu' | 'cpu';
+    onStatus?: (status: EngineStatus) => void;
+    onProgress?: (progress: {
+        loaded: number;
+        total: number;
+    }) => void;
+    /** Reports whether a usable WebGPU adapter was detected (after load). */
+    onBackend?: (info: {
+        webgpu: boolean;
+        using: 'webgpu' | 'cpu';
+    }) => void;
+}
+/** Resolve a HF model ref to its `resolve/main` GGUF URL: `{basename}-{version}-{quant}.gguf`. */
+declare function resolveModelUrl(ref?: HFModelRef): string;
+/**
+ * Real engine: runs the GGUF in-browser via wllama (llama.cpp WASM/WebGPU). Loads the model from
+ * Hugging Face by default (configurable), caches it in OPFS, and applies the GBNF grammar at decode.
+ * Framework-agnostic - reports lifecycle via callbacks, no store coupling.
+ */
+declare class WllamaEngine implements AgentEngine {
+    private readonly config;
+    private wllamaPromise;
+    private warnedSystemSize;
+    private readonly url;
+    private readonly nCtx;
+    private readonly maxTokens;
+    constructor(config: WllamaEngineConfig);
+    load(): Promise<void>;
+    /** Tear down the loaded model so it can be reloaded (e.g. on a backend switch). OPFS-cached. */
+    reset(): Promise<void>;
+    private getWllama;
+    generate(messages: ChatMessage[], grammar?: string): Promise<EngineGenerateResult>;
+}
+
+/**
+ * Fixture engine with no model weights - for building/testing the loop, tools, and UI without
+ * loading the real model. Emits calls on the current v1.0.0 contract (`search_catalog`,
+ * `search_knowledge`, `add_to_cart(id)`). Ignores the grammar.
+ */
+declare class StubEngine implements AgentEngine {
+    generate(messages: ChatMessage[], _grammar?: string): Promise<EngineGenerateResult>;
+}
+
+declare function buildToolGrammar(tools: ToolSchema[], validIds?: string[], idKeys?: string[], allowText?: boolean): string;
+/** Collect string values under `id` keys from an arbitrary tool result (search results carry them). */
+declare function collectIds(value: unknown, into: Set<string>): void;
+
+interface SystemPromptConfig {
+    /** 1-2 line persona/rules for this deployment (who the assistant is, grounding + refusal rules). */
+    persona: string;
+    /** The tool schemas to advertise (same array the loop dispatches). */
+    toolSchemas: ToolSchema[];
+    /** A short "headline entities" hint (`Title [id]; ...`) or a provider for it. Optional. */
+    catalogHint?: string | (() => string | Promise<string>);
+    /** Label before the hint. Defaults to the trained `"Example catalog items"`. */
+    hintLabel?: string;
+}
+/**
+ * Reproduce the exact v1.0.0 system message the model was trained on:
+ *   `{persona}\n\n{hintLabel}: {hint}\nList of tools: [{fn-json}, ...]`
+ * The tool list uses Python `json.dumps` separators (`pyJson`) for byte-for-byte train/inference
+ * parity. The full system text is baked here (pass NO `tools` array to the engine's chat template).
+ */
+declare function buildSystemPrompt(cfg: SystemPromptConfig): Promise<string>;
+
+/**
+ * Serialize a value the way Python's json.dumps (and Jinja2's `tojson`) does by default:
+ * ", " between items and ": " after keys. The model's chat template renders the tool list
+ * with these separators, so the browser must match them byte-for-byte for train/inference
+ * parity. (Our tool schemas are ASCII with no <,>,& so htmlsafe escaping never triggers.)
+ */
+declare function pyJson(v: unknown): string;
+
+interface ParsedToolCall {
+    name: string;
+    args: Record<string, unknown>;
+}
+interface ParseResult {
+    text: string;
+    toolCalls: ParsedToolCall[];
+}
+/**
+ * Extracts pythonic tool calls (e.g. `[search_products(query="x"), add_to_cart(slug="y", quantity=2)]`)
+ * from LFM2.5's tool_call_start/end markers, and returns the remaining plain text.
+ * Never uses eval - parses the restricted call grammar by hand.
+ */
+declare function parseToolCalls(raw: string): ParseResult;
+
+declare function renderToolCalls(calls: ParsedToolCall[]): string;
+
+declare const N_CTX = 8192;
+declare const MAX_OUTPUT_TOKENS = 320;
+declare const SYSTEM_CTX_WARN_FRACTION = 0.15;
+declare const HISTORY_TOKEN_BUDGET: number;
+declare const estimateTokens: (text: string | undefined) => number;
+
+export { type AgentConfig, type AgentEngine, type AgentEvent, type ChatMessage, type EngineGenerateResult, type EngineStatus, type HFModelRef, HISTORY_TOKEN_BUDGET, MAX_OUTPUT_TOKENS, N_CTX, type ParseResult, type ParsedToolCall, SYSTEM_CTX_WARN_FRACTION, type Session, StubEngine, type SubmitOptions, type SystemPromptConfig, type ToolCall, ToolDefinition, ToolHandler, type ToolRegistry, ToolSchema, WllamaEngine, type WllamaEngineConfig, buildRegistry, buildSystemPrompt, buildToolGrammar, collectIds, createAgent, estimateTokens, parseToolCalls, pyJson, renderToolCalls, resolveModelUrl };