@kaleidorg/mind 0.0.1 → 0.2.0

package/src/tools/l402.test.ts

@@ -0,0 +1,113 @@
+/**
+ * L402 tool tests — the "agent pays for a tool in sats" flow, deterministic
+ * with a stubbed fetch. No network, no model.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { createL402ToolSource, parseL402Challenge, bolt11AmountSats } from './l402.js';
+
+describe('L402 helpers', () => {
+  it('parses an L402 challenge header', () => {
+    const h = 'L402 macaroon="AbCdEf==", invoice="lnbc100n1xyz"';
+    expect(parseL402Challenge(h)).toEqual({ macaroon: 'AbCdEf==', invoice: 'lnbc100n1xyz' });
+  });
+
+  it('returns null when the header is not an L402 challenge', () => {
+    expect(parseL402Challenge('Bearer xyz')).toBeNull();
+  });
+
+  it('parses bolt11 amounts to sats', () => {
+    expect(bolt11AmountSats('lnbc100n1xyz')).toBe(10); // 100 nano-BTC = 10 sats
+    expect(bolt11AmountSats('lnbc1u1xyz')).toBe(100); // 1 micro-BTC = 100 sats
+    expect(bolt11AmountSats('lnbc2500u1xyz')).toBe(250_000);
+  });
+});
+
+describe('createL402ToolSource — pay-and-fetch flow', () => {
+  it('pays the invoice on 402 then re-fetches with the L402 token', async () => {
+    const payInvoice = vi.fn(async () => ({ preimage: 'deadbeefpreimage' }));
+
+    // First call → 402 with a challenge; second (authed) call → 200 with data.
+    const fetchImpl = vi
+      .fn()
+      .mockResolvedValueOnce({
+        status: 402,
+        ok: false,
+        headers: new Map([
+          ['www-authenticate', 'L402 macaroon="MAC123", invoice="lnbc100n1demo"'],
+        ]) as any,
+      })
+      .mockResolvedValueOnce({
+        status: 200,
+        ok: true,
+        headers: new Map() as any,
+        async text() {
+          return JSON.stringify({ btc_usd: 73000 });
+        },
+      });
+
+    const src = createL402ToolSource({ payInvoice, fetchImpl: fetchImpl as unknown as typeof fetch });
+
+    const result = await src.execute('fetch_paid_resource', { url: 'https://api.example/premium/price' });
+
+    // paid the right invoice + amount (100n = 10 sats)
+    expect(payInvoice).toHaveBeenCalledWith('lnbc100n1demo', 10);
+    // second fetch carried the L402 Authorization header
+    const secondCallArgs = fetchImpl.mock.calls[1];
+    expect(secondCallArgs[1].headers.Authorization).toBe('L402 MAC123:deadbeefpreimage');
+    // returned the parsed JSON resource
+    expect(result).toEqual({ btc_usd: 73000 });
+  });
+
+  it('returns the resource directly when no payment is required (200)', async () => {
+    const payInvoice = vi.fn();
+    const fetchImpl = vi.fn().mockResolvedValueOnce({
+      status: 200,
+      ok: true,
+      headers: new Map() as any,
+      async text() {
+        return 'plain text resource';
+      },
+    });
+    const src = createL402ToolSource({ payInvoice, fetchImpl: fetchImpl as unknown as typeof fetch });
+
+    const result = await src.execute('fetch_paid_resource', { url: 'https://api.example/free' });
+
+    expect(payInvoice).not.toHaveBeenCalled();
+    expect(result).toBe('plain text resource');
+  });
+
+  it('exposes the tool with confirmation required (money tool)', () => {
+    const src = createL402ToolSource({ payInvoice: vi.fn() });
+    const tools = src.listTools();
+    expect(tools).toHaveLength(1);
+    expect(tools[0].name).toBe('fetch_paid_resource');
+    expect(tools[0].requiresConfirmation).toBe(true);
+  });
+
+  it('honours requiresConfirmation: false (auto-pay hosts)', () => {
+    const src = createL402ToolSource({ payInvoice: vi.fn(), requiresConfirmation: false });
+    expect(src.listTools()[0].requiresConfirmation).toBe(false);
+  });
+
+  it('declines invoices above maxAutoPaySats', async () => {
+    const payInvoice = vi.fn(async () => ({ preimage: 'x' }));
+    const fetchImpl = vi.fn().mockResolvedValueOnce({
+      status: 402,
+      ok: false,
+      headers: new Map([
+        // 2500u = 250,000 sats — above the 1000 cap
+        ['www-authenticate', 'L402 macaroon="M", invoice="lnbc2500u1big"'],
+      ]) as any,
+    });
+    const src = createL402ToolSource({
+      payInvoice,
+      maxAutoPaySats: 1000,
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    });
+    await expect(src.execute('fetch_paid_resource', { url: 'https://x/y' })).rejects.toThrow(
+      /above the 1000 sat auto-pay cap/,
+    );
+    expect(payInvoice).not.toHaveBeenCalled();
+  });
+});

package/src/tools/l402.ts

@@ -0,0 +1,122 @@
+/**
+ * L402 tool source — lets the agent pay for paywalled HTTP resources in sats.
+ *
+ * Exposes one tool, `fetch_paid_resource(url)`, that runs the L402 flow:
+ *   GET url → 402 with an L402 challenge (macaroon + Lightning invoice)
+ *   → pay the invoice (via the injected `payInvoice`, e.g. the on-device wallet)
+ *   → re-GET with `Authorization: L402 <macaroon>:<preimage>` → return the body.
+ *
+ * This is the "agent pays for a tool in sats" capability: any KaleidoMind agent
+ * (mobile or desktop) can buy premium data / inference autonomously. Payment
+ * runs through the host's wallet, so it stays on-device; the engine's
+ * confirmation gate can wrap the spend if desired.
+ *
+ * No dependencies — uses global fetch (Node ≥18, React Native). The fetch impl
+ * is injectable for testing.
+ */
+
+import type { ToolDef } from '../types.js';
+import type { ToolSource } from './source.js';
+
+export interface L402PayResult {
+  /** Payment preimage (hex) — proves the invoice was paid. */
+  preimage: string;
+}
+
+export interface L402Options {
+  /** Pay a BOLT11 invoice, resolve with the preimage. Wallet on device; mock in tests. */
+  payInvoice: (invoice: string, amountSats: number) => Promise<L402PayResult>;
+  /** Override fetch (tests). Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Optional progress logging. */
+  log?: (msg: string) => void;
+  /**
+   * Gate the tool behind the engine's confirmation (default true). The catch:
+   * the invoice amount is only known DURING execution (the 402 challenge), so a
+   * pre-execution confirmation can't show it. On hosts without a dedicated L402
+   * confirmation UX, set this false and bound spending with `maxAutoPaySats`.
+   */
+  requiresConfirmation?: boolean;
+  /** Auto-pay only invoices up to this many sats; reject larger ones. */
+  maxAutoPaySats?: number;
+}
+
+/** Parse an L402 (or legacy LSAT) WWW-Authenticate challenge. */
+export function parseL402Challenge(header: string): { macaroon: string; invoice: string } | null {
+  const macaroon = header.match(/macaroon="([^"]+)"/i)?.[1];
+  const invoice = header.match(/invoice="([^"]+)"/i)?.[1];
+  return macaroon && invoice ? { macaroon, invoice } : null;
+}
+
+/** Rough BOLT11 amount → sats (for logging / spend caps). 0 if unparseable. */
+export function bolt11AmountSats(invoice: string): number {
+  const m = invoice.match(/^ln(?:bc|tb|bcrt)(\d+)([munp]?)/i);
+  if (!m) return 0;
+  const n = Number(m[1]);
+  const mult = (m[2] || '').toLowerCase();
+  const btc = mult === 'm' ? n / 1e3 : mult === 'u' ? n / 1e6 : mult === 'n' ? n / 1e9 : mult === 'p' ? n / 1e12 : n;
+  return Math.round(btc * 1e8);
+}
+
+export function createL402ToolSource(opts: L402Options): ToolSource {
+  const doFetch = opts.fetchImpl ?? fetch;
+
+  const tool: ToolDef = {
+    name: 'fetch_paid_resource',
+    description:
+      'Fetch a paywalled (L402) HTTP resource, automatically paying the required ' +
+      'Lightning invoice in sats. Use this for premium or paid APIs (market data, ' +
+      'inference, etc.). Pass the resource URL.',
+    parameters: {
+      type: 'object',
+      properties: { url: { type: 'string', description: 'The resource URL to fetch' } },
+      required: ['url'],
+    },
+    requiresConfirmation: opts.requiresConfirmation ?? true,
+  };
+
+  async function execute(_name: string, args: Record<string, unknown>): Promise<unknown> {
+    const url = String(args.url ?? '');
+    if (!url) throw new Error('fetch_paid_resource: url is required');
+
+    let res = await doFetch(url);
+
+    if (res.status === 402) {
+      const challenge = parseL402Challenge(res.headers.get('www-authenticate') ?? '');
+      if (!challenge) throw new Error('402 Payment Required but no L402 challenge present');
+
+      const amountSats =
+        bolt11AmountSats(challenge.invoice) || Number(res.headers.get('x-amount-sats') ?? 0);
+
+      if (opts.maxAutoPaySats != null && amountSats > opts.maxAutoPaySats) {
+        throw new Error(
+          `L402 invoice is ${amountSats} sats, above the ${opts.maxAutoPaySats} sat auto-pay cap — declined`,
+        );
+      }
+
+      opts.log?.(`L402: ${url} requires ${amountSats} sats — paying…`);
+
+      const { preimage } = await opts.payInvoice(challenge.invoice, amountSats);
+
+      res = await doFetch(url, {
+        headers: { Authorization: `L402 ${challenge.macaroon}:${preimage}` },
+      });
+      opts.log?.(`L402: paid ${amountSats} sats → ${res.status}`);
+    }
+
+    if (!res.ok) throw new Error(`fetch_paid_resource: ${res.status} ${res.statusText}`);
+    const body = await res.text();
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+
+  return {
+    id: 'l402',
+    listTools: () => [tool],
+    has: (name) => name === tool.name,
+    execute,
+  };
+}

package/src/tools/mcp.ts

@@ -13,8 +13,9 @@
  * file type-checks and ships even where the SDK isn't installed; constructing
  * an McpToolSource without it throws a clear error.
  *
- * STATUS: skeleton for the desktop pass. The shape is final; the connect()
- * body is wired when we integrate desktop-app.
+ * Wired end-to-end: connect() (stdio + HTTP transports), listTools() and
+ * execute() are implemented. Used by the desktop sidecar (kaleido-mcp +
+ * Bitrefill MCP) and verified against the remote Bitrefill MCP.
  */
 
 import type { ToolDef } from '../types.js';

package/src/wallet/contract.test.ts

@@ -0,0 +1,89 @@
+/** Wallet contract tests — integrity of the single source of truth. */
+
+import { describe, it, expect, vi } from 'vitest';
+import {
+  WALLET_TOOLS,
+  SPEND_TOOLS,
+  isSpendTool,
+  walletTools,
+  toToolDefs,
+  bindWalletTools,
+  getWalletTool,
+} from './contract.js';
+
+describe('WALLET_TOOLS contract', () => {
+  it('has unique names and object schemas', () => {
+    const names = WALLET_TOOLS.map((t) => t.name);
+    expect(new Set(names).size).toBe(names.length);
+    for (const t of WALLET_TOOLS) {
+      expect(t.name).toMatch(/^[a-z][a-z0-9_]+$/);
+      expect((t.parameters as any).type).toBe('object');
+    }
+  });
+
+  it('namespaces per-layer tools and keeps core helpers unprefixed', () => {
+    for (const t of WALLET_TOOLS) {
+      if (t.layer === 'core') continue;
+      expect(t.name.startsWith(`${t.layer}_`)).toBe(true);
+    }
+    expect(getWalletTool('send_payment')!.layer).toBe('core');
+    expect(getWalletTool('resolve_contact')!.layer).toBe('core');
+  });
+
+  it('spend tools are confirmation-gated; reads do not move funds', () => {
+    for (const t of WALLET_TOOLS) {
+      expect(!!t.requiresConfirmation).toBe(!!t.spend);
+    }
+    // every fund-moving tool is flagged
+    expect(isSpendTool('send_payment')).toBe(true);
+    expect(isSpendTool('rln_send_asset')).toBe(true);
+    expect(isSpendTool('execute_swap')).toBe(true);
+    expect(isSpendTool('spark_send')).toBe(true);
+    // reads are not
+    expect(isSpendTool('get_balances')).toBe(false);
+    expect(isSpendTool('get_price')).toBe(false);
+    expect([...SPEND_TOOLS].length).toBeGreaterThanOrEqual(5);
+  });
+
+  it('required args declared on the actionable tools', () => {
+    expect((getWalletTool('send_payment')!.parameters as any).required).toContain('to');
+    expect((getWalletTool('fiat_to_sats')!.parameters as any).required).toEqual(['amount', 'currency']);
+    expect((getWalletTool('rln_create_rgb_invoice')!.parameters as any).required).toEqual(['asset', 'amount']);
+  });
+});
+
+describe('selectors', () => {
+  it('walletTools filters by layer + always includes core unless disabled', () => {
+    const spark = walletTools({ layers: ['spark'] });
+    expect(spark.some((t) => t.name === 'spark_send')).toBe(true);
+    expect(spark.some((t) => t.layer === 'core')).toBe(true); // core included by default
+    expect(spark.some((t) => t.layer === 'rln')).toBe(false);
+
+    const noCore = walletTools({ layers: ['spark'], includeCore: false });
+    expect(noCore.every((t) => t.layer === 'spark')).toBe(true);
+  });
+
+  it('toToolDefs strips metadata but keeps requiresConfirmation', () => {
+    const defs = toToolDefs(walletTools({ layers: ['spark'] }));
+    const send = defs.find((d) => d.name === 'spark_send')!;
+    expect(send.requiresConfirmation).toBe(true);
+    expect('layer' in (send as any)).toBe(false);
+  });
+});
+
+describe('bindWalletTools', () => {
+  it('binds handlers → an InProcessToolSource with spend flags preserved', async () => {
+    const handler = vi.fn(async () => ({ ok: true }));
+    const src = bindWalletTools({ spark_get_balance: handler, spark_send: handler }, { layers: ['spark'], includeCore: false, allowMissing: true });
+    const tools = src.listTools();
+    expect(tools.map((t) => t.name).sort()).toEqual(['spark_get_balance', 'spark_send']);
+    expect(tools.find((t) => t.name === 'spark_send')!.requiresConfirmation).toBe(true);
+    expect(await src.execute('spark_get_balance', {})).toEqual({ ok: true });
+  });
+
+  it('throws on a missing handler unless allowMissing', () => {
+    expect(() => bindWalletTools({}, { layers: ['spark'], includeCore: false })).toThrow(/no handler/);
+    const src = bindWalletTools({ spark_get_balance: async () => 1 }, { layers: ['spark'], includeCore: false, allowMissing: true });
+    expect(src.listTools().map((t) => t.name)).toEqual(['spark_get_balance']);
+  });
+});

package/src/wallet/contract.ts

@@ -0,0 +1,157 @@
+/**
+ * Canonical multi-L2 wallet tool contract — the single source of truth for
+ * KaleidoMind's wallet tools (names + JSON schemas + spend flags).
+ *
+ * Every surface implements THESE EXACT tools, only the transport differs:
+ *   - mobile  → in-process handlers over the WDK adapters (`bindWalletTools`)
+ *   - desktop → kaleido-mcp (tools namespaced per layer) + a `kaleido` CLI
+ *   - eval    → stub handlers
+ *
+ * Because the schemas are identical everywhere, skills are portable and the
+ * model comparison is honest. Tools are namespaced per layer (`spark_*`,
+ * `rln_*`, `arkade_*`, `liquid_*`); cross-cutting router/helpers are unprefixed.
+ *
+ * Spend tools (move funds) carry `spend: true` → `requiresConfirmation: true`,
+ * so the Engine always pauses for the host's confirm gate before executing.
+ *
+ * Pure data — no deps, RN-safe.
+ */
+
+import type { ToolDef } from '../types.js';
+import { InProcessToolSource } from '../tools/in-process.js';
+import type { InProcessTool } from '../tools/in-process.js';
+
+export type WalletLayer = 'spark' | 'rln' | 'arkade' | 'liquid' | 'core';
+
+export interface WalletToolDef extends ToolDef {
+  /** Which L2 (or 'core' for cross-cutting router/helpers). */
+  layer: WalletLayer;
+  /** Moves funds → confirmation-gated. */
+  spend?: boolean;
+}
+
+type Props = Record<string, { type: string; description?: string; enum?: string[] }>;
+
+function t(
+  layer: WalletLayer,
+  name: string,
+  description: string,
+  properties: Props = {},
+  required: string[] = [],
+  spend = false,
+): WalletToolDef {
+  return {
+    layer,
+    name,
+    description,
+    spend,
+    requiresConfirmation: spend,
+    parameters: { type: 'object', properties, required },
+  };
+}
+
+const sats = { type: 'number', description: 'Amount in satoshis' } as const;
+const asset = { type: 'string', description: "Asset ticker, e.g. 'USDT', 'XAUT', 'BTC'" } as const;
+
+/** The full contract. Keep descriptions terse — small models read every word. */
+export const WALLET_TOOLS: WalletToolDef[] = [
+  // ── Spark ──────────────────────────────────────────────────────────────
+  t('spark', 'spark_get_balance', 'Get the Spark wallet BTC balance.'),
+  t('spark', 'spark_get_address', 'Get a Spark deposit address to receive BTC.'),
+  t('spark', 'spark_create_invoice', 'Create a Spark Lightning invoice to receive BTC.', { amount_sats: sats }),
+  t('spark', 'spark_send', 'Send BTC from Spark to an address or invoice.', { amount_sats: sats, to: { type: 'string', description: 'Address or invoice' } }, ['amount_sats', 'to'], true),
+
+  // ── RLN / RGB ──────────────────────────────────────────────────────────
+  t('rln', 'rln_get_balances', 'Get RLN node balances (BTC + RGB assets).'),
+  t('rln', 'rln_get_node_info', 'Get RLN node status and sync state.'),
+  t('rln', 'rln_list_channels', 'List the RLN node Lightning channels.'),
+  t('rln', 'rln_create_ln_invoice', 'Create a Lightning (BTC) invoice on the RLN node.', { amount_sats: sats }),
+  t('rln', 'rln_create_rgb_invoice', 'Create an RGB asset invoice to receive an asset (e.g. USDT).', { asset, amount: { type: 'number', description: 'Asset amount' } }, ['asset', 'amount']),
+  t('rln', 'rln_pay_invoice', 'Pay a Lightning invoice from the RLN node.', { invoice: { type: 'string' } }, ['invoice'], true),
+  t('rln', 'rln_send_asset', 'Send an RGB asset (e.g. USDT) to a recipient.', { asset, amount: { type: 'number' }, to: { type: 'string' } }, ['asset', 'amount', 'to'], true),
+
+  // ── Arkade ─────────────────────────────────────────────────────────────
+  t('arkade', 'arkade_get_balance', 'Get the Arkade wallet balance.'),
+  t('arkade', 'arkade_get_address', 'Get an Arkade address to receive funds.'),
+  t('arkade', 'arkade_send', 'Send BTC from Arkade to a recipient.', { amount_sats: sats, to: { type: 'string' } }, ['amount_sats', 'to'], true),
+
+  // ── Liquid (later) ─────────────────────────────────────────────────────
+  t('liquid', 'liquid_get_balance', 'Get the Liquid wallet balance (L-BTC + assets).'),
+  t('liquid', 'liquid_create_invoice', 'Create a Liquid invoice/address to receive (L-BTC or L-USDt).', { asset, amount: { type: 'number' } }),
+  t('liquid', 'liquid_send', 'Send a Liquid asset (L-BTC or L-USDt) to a recipient.', { asset, amount: { type: 'number' }, to: { type: 'string' } }, ['asset', 'amount', 'to'], true),
+
+  // ── Core: router + helpers ─────────────────────────────────────────────
+  t('core', 'get_balances', 'Get balances across all layers (or one layer).', { layer: { type: 'string', enum: ['spark', 'rln', 'arkade', 'liquid'], description: 'Optional: a single layer' } }),
+  t('core', 'resolve_contact', 'Resolve a contact name to a Lightning address / Nostr / preferred rail.', { name: { type: 'string', description: 'Contact name, e.g. "bob"' } }, ['name']),
+  t('core', 'get_price', 'Get the current price of an asset, optionally in a fiat currency.', { asset, fiat: { type: 'string', description: "Fiat code, e.g. 'EUR', 'USD'" } }),
+  t('core', 'fiat_to_sats', 'Convert a fiat amount to satoshis at the current rate.', { amount: { type: 'number' }, currency: { type: 'string', description: "Fiat code, e.g. 'EUR'" } }, ['amount', 'currency']),
+  t('core', 'get_swap_quote', 'Quote a swap between two assets.', { from_asset: asset, to_asset: asset, amount: { type: 'number' } }, ['from_asset', 'to_asset', 'amount']),
+  t('core', 'execute_swap', 'Execute a previously quoted swap.', { quote_id: { type: 'string' }, from_asset: asset, to_asset: asset, amount: { type: 'number' } }, [], true),
+  // The high-level entry a skill prefers — picks the rail for the asset, or uses `layer`.
+  t('core', 'send_payment', 'Send a payment, automatically choosing the best layer for the asset (or use `layer`).', { asset, amount_sats: sats, to: { type: 'string', description: 'Contact, address, or invoice' }, layer: { type: 'string', enum: ['spark', 'rln', 'arkade', 'liquid'] } }, ['to'], true),
+  // High-level receive — picks the right invoice/address tool for the asset/layer.
+  t('core', 'create_invoice', 'Create an invoice or address to receive funds, choosing the rail for the asset (or use `layer`). Omit amount for an any-amount invoice.', { asset, amount: { type: 'number', description: 'Amount (sats for BTC, asset units otherwise) — optional' }, layer: { type: 'string', enum: ['spark', 'rln', 'arkade', 'liquid'] } }),
+];
+
+// ── Selectors ───────────────────────────────────────────────────────────────
+
+export const WALLET_LAYERS: WalletLayer[] = ['spark', 'rln', 'arkade', 'liquid', 'core'];
+
+/** Names of all spend (fund-moving) tools — these are confirmation-gated. */
+export const SPEND_TOOLS: ReadonlySet<string> = new Set(WALLET_TOOLS.filter((x) => x.spend).map((x) => x.name));
+
+export function isSpendTool(name: string): boolean {
+  return SPEND_TOOLS.has(name);
+}
+
+export function getWalletTool(name: string): WalletToolDef | undefined {
+  return WALLET_TOOLS.find((x) => x.name === name);
+}
+
+/** Pick the contract tools for the given layers (core helpers included by default). */
+export function walletTools(opts: { layers?: WalletLayer[]; includeCore?: boolean } = {}): WalletToolDef[] {
+  const layers = new Set(opts.layers ?? (['spark', 'rln', 'arkade', 'liquid'] as WalletLayer[]));
+  if (opts.includeCore !== false) layers.add('core');
+  return WALLET_TOOLS.filter((x) => layers.has(x.layer));
+}
+
+/** Strip to plain ToolDefs (drop the layer/spend metadata). */
+export function toToolDefs(tools: WalletToolDef[]): ToolDef[] {
+  return tools.map(({ name, description, parameters, requiresConfirmation }) => ({ name, description, parameters, requiresConfirmation }));
+}
+
+/** A handler bound to one contract tool. */
+export type WalletHandler = (args: Record<string, unknown>) => Promise<unknown>;
+
+export interface BindWalletOptions {
+  layers?: WalletLayer[];
+  includeCore?: boolean;
+  /** Skip tools that have no handler instead of throwing (default false). */
+  allowMissing?: boolean;
+  id?: string;
+}
+
+/**
+ * Bind contract tools to in-process handlers → an InProcessToolSource. The
+ * mobile (and eval) binding: pass a map of `{ toolName: handler }` and you get a
+ * ToolSource implementing the canonical schemas with spend flags preserved.
+ */
+export function bindWalletTools(handlers: Record<string, WalletHandler>, opts: BindWalletOptions = {}): InProcessToolSource {
+  const tools = walletTools(opts);
+  const bound: InProcessTool[] = [];
+  for (const def of tools) {
+    const handler = handlers[def.name];
+    if (!handler) {
+      if (opts.allowMissing) continue;
+      throw new Error(`bindWalletTools: no handler for "${def.name}"`);
+    }
+    bound.push({
+      name: def.name,
+      description: def.description,
+      parameters: def.parameters,
+      requiresConfirmation: def.requiresConfirmation,
+      handler,
+    });
+  }
+  return new InProcessToolSource(opts.id ?? 'wallet', bound);
+}

package/dist/providers/qvac.d.ts

@@ -1,89 +0,0 @@
-/**
- * QVAC provider — primary, on-device.
- *
- * Wraps the QVAC SDK's llamacpp-completion plugin. The actual binding
- * differs slightly per host (RN vs Node vs browser worker), so the heavy
- * lifting is delegated to a `QvacBinding` injected by the adapter packages.
- *
- * Node (kaleido-agent):       binding = await import('@qvac/sdk/node')
- * React Native (rate):        binding from @kaleido/mind-rn → wraps QVACService
- * Browser (rate-extension):   binding from @kaleido/mind-browser → talks to worker
- */
-import type { LLMProvider, ProviderConfig, ProviderRunOptions, ProviderRunResult } from './types.js';
-import type { Message, ToolDef, TurnEvent } from '../types.js';
-/**
- * Host-injected binding. Each adapter package supplies its own.
- * We keep this duck-typed (not an abstract class) so adapters
- * don't have to extend anything heavy.
- */
-export interface QvacBinding {
-    load(modelPath: string, opts: {
-        contextSize: number;
-        backend?: 'metal' | 'cpu' | 'auto';
-    }): Promise<void>;
-    unload(): Promise<void>;
-    isReady(): boolean;
-    /** Synchronous completion. The adapter handles the QVAC SDK plumbing. */
-    complete(prompt: string, opts: {
-        maxTokens?: number;
-        temperature?: number;
-        topP?: number;
-        stop?: string[];
-        signal?: AbortSignal;
-    }): Promise<{
-        text: string;
-        usage?: {
-            prompt: number;
-            completion: number;
-        };
-    }>;
-    /** Streaming completion — yields token strings. */
-    stream(prompt: string, opts: {
-        maxTokens?: number;
-        temperature?: number;
-        topP?: number;
-        stop?: string[];
-        signal?: AbortSignal;
-    }): AsyncIterable<string>;
-}
-export interface QvacProviderOpts extends ProviderConfig {
-    binding: QvacBinding;
-    /**
-     * Chat template family. Auto-detect from model name when omitted.
-     *   'qwen3' — Qwen 3 family (thinking-mode aware)
-     *   'hermes' — Hermes 3/4 family
-     *   'llama3' — Llama 3.x Instruct
-     *   'chatml' — generic ChatML
-     */
-    template?: 'qwen3' | 'hermes' | 'llama3' | 'chatml';
-    backend?: 'metal' | 'cpu' | 'auto';
-}
-export declare class QvacProvider implements LLMProvider {
-    readonly name = "qvac";
-    readonly modelId: string;
-    private readonly binding;
-    private readonly contextSize;
-    private readonly temperature;
-    private readonly topP;
-    private readonly template;
-    private readonly backend;
-    constructor(opts: QvacProviderOpts);
-    load(): Promise<void>;
-    unload(): Promise<void>;
-    isReady(): boolean;
-    run(messages: Message[], tools: ToolDef[], opts?: ProviderRunOptions): Promise<ProviderRunResult>;
-    stream(messages: Message[], tools: ToolDef[], opts?: ProviderRunOptions): AsyncIterable<TurnEvent>;
-    private detectTemplate;
-    /**
-     * Render messages + tools into the model's chat template.
-     * TODO: full implementations per family. This stub uses a minimal
-     * tool-aware ChatML rendering that works for Qwen3 / Hermes / Llama 3.
-     */
-    private formatPrompt;
-    /**
-     * Parse the model's text output into (text, tool_calls).
-     * Recognises <tool_call>{...}</tool_call> blocks.
-     */
-    private parseCompletion;
-}
-//# sourceMappingURL=qvac.d.ts.map

package/dist/providers/qvac.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"qvac.d.ts","sourceRoot":"","sources":["../../src/providers/qvac.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,OAAO,EAAY,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEzE;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1G,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,OAAO,IAAI,OAAO,CAAC;IACnB,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;QAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC,CAAC;IAC9E,mDAAmD;IACnD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACtD,OAAO,EAAE,WAAW,CAAC;IACrB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACpD,OAAO,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;CACpC;AAED,qBAAa,YAAa,YAAW,WAAW;IAC9C,SAAgB,IAAI,UAAU;IAC9B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAEhC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4C;IACrE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2C;gBAEvD,IAAI,EAAE,gBAAgB;IAU5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAQrB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B,OAAO,IAAI,OAAO;IAIZ,GAAG,CACP,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,iBAAiB,CAAC;IAYtB,MAAM,CACX,QAAQ,EAAE,OAAO,EAAE,EACnB,KAAK,EAAE,OAAO,EAAE,EAChB,IAAI,GAAE,kBAAuB,GAC5B,aAAa,CAAC,SAAS,CAAC;IAoB3B,OAAO,CAAC,cAAc;IAQtB;;;;OAIG;IACH,OAAO,CAAC,YAAY;IA+BpB;;;OAGG;IACH,OAAO,CAAC,eAAe;CAwBxB"}