@kaleidorg/mind 0.8.1 → 0.10.0

package/src/index.ts

@@ -49,6 +49,7 @@ export {
   walletTools,
   toToolDefs,
   bindWalletTools,
+  normalizeWalletArgs,
 } from './wallet/contract.js';
 export type {
   WalletLayer,
@@ -71,102 +72,9 @@ export {
 export { annotateRgbBalances, fixRgbBalanceUnits, formatRgbAmount } from './context/rgb-units.js';
 export type { ArgValidation, UngroundedItem, WalletAction } from './guards.js';
 
-// ── KaleidoSwap maker tool contract (single source of truth) ────────────────
-export {
-  KALEIDOSWAP_TOOLS,
-  KALEIDOSWAP_SPEND_TOOLS,
-  isKaleidoswapSpendTool,
-  getKaleidoswapTool,
-  kaleidoswapTools,
-  bindKaleidoswapTools,
-} from './kaleidoswap/contract.js';
-export type {
-  KaleidoswapGroup,
-  KaleidoswapToolDef,
-  KaleidoswapHandler,
-  BindKaleidoswapOptions,
-} from './kaleidoswap/contract.js';
-
-// ── LSPS1 (Lightning Service Provider channel orders) ───────────────────────
-export {
-  LSPS1_TOOLS,
-  LSPS1_SPEND_TOOLS,
-  isLsps1SpendTool,
-  getLsps1Tool,
-  bindLsps1Tools,
-} from './lsps1/contract.js';
-export type {
-  Lsps1ToolDef,
-  Lsps1Handler,
-  BindLsps1Options,
-} from './lsps1/contract.js';
-
-// ── KaleidoSwap /v2 submarine swaps (pay Lightning from Liquid) ─────────────
-export {
-  SUBMARINE_TOOLS,
-  SUBMARINE_SPEND_TOOLS,
-  SUBMARINE_FROM_ASSETS,
-  isSubmarineSpendTool,
-  getSubmarineTool,
-  formatSubmarineAmount,
-  bindSubmarineTools,
-} from './submarine/contract.js';
-export type {
-  SubmarineToolDef,
-  SubmarineFromAsset,
-  SubmarineHandler,
-  BindSubmarineOptions,
-} from './submarine/contract.js';
-
-// ── Bitrefill (gift cards / mobile top-ups / eSIMs) ─────────────────────────
-export {
-  BITREFILL_TOOLS,
-  BITREFILL_SPEND_TOOLS,
-  isBitrefillSpendTool,
-  getBitrefillTool,
-  bindBitrefillTools,
-} from './bitrefill/contract.js';
-export type {
-  BitrefillToolDef,
-  BitrefillHandler,
-  BindBitrefillOptions,
-} from './bitrefill/contract.js';
-
-// ── Flashnet (Spark-native AMM — swaps over Spark) ──────────────────────────
-export {
-  FLASHNET_TOOLS,
-  FLASHNET_SPEND_TOOLS,
-  isFlashnetSpendTool,
-  getFlashnetTool,
-  bindFlashnetTools,
-} from './flashnet/contract.js';
-export type {
-  FlashnetToolDef,
-  FlashnetHandler,
-  BindFlashnetOptions,
-} from './flashnet/contract.js';
-
-// ── KaleidoSwap recipes (opt-in — register via Funnel.recipes) ──
-// price recipe is read-only (quote-only); atomic recipe runs the full swap.
-// Register the price recipe FIRST so phrasings like "BTC price" are answered
-// without firing any spend.
-export { kaleidoswapPriceRecipe } from './recipe/kaleidoswap-price.js';
-export { kaleidoswapAtomicRecipe } from './recipe/kaleidoswap-atomic.js';
-export { flashnetSwapRecipe } from './recipe/flashnet-swap.js';
-export {
-  kaleidoswapChannelOrderRecipe,
-  extractChannelOrder,
-} from './recipe/kaleidoswap-channel-order.js';
-
-// ── Buy-an-asset-channel recipe (opt-in — register via Funnel.recipes) ─────
-export { buyAssetChannelRecipe, extractBuyAsset } from './recipe/buy-asset-channel.js';
-
 // ── Issue-an-RGB-asset recipe (opt-in — register via Funnel.recipes) ───────
 export { issueAssetRecipe, extractIssueAsset } from './recipe/issue-asset.js';
 
-// ── Submarine-pay recipe (opt-in — register via Funnel.recipes, before payments) ──
-export { submarinePayRecipe, extractSubmarinePay } from './recipe/submarine-pay.js';
-
 // ── Recipes (mobile multi-step: "recipes, not planning") ───────────────────
 export { runRecipe, extractSlots, RecipeRegistry } from './recipe/runner.js';
 export type { RunRecipeOptions } from './recipe/runner.js';
@@ -224,20 +132,16 @@ export type { ToolCrushOptions, CrushResult } from './context/compress.js';
 export { capabilityProfile } from './capabilities.js';
 export type { CapabilityInput, MindCapabilities } from './capabilities.js';
 
-// ── Knowledge packs + corpus adapters (for RAG) ────────────────────────────
-export { BITCOIN_COPILOT_DOCS } from './knowledge/bitcoin-copilot.js';
-export { walletHistoryToDocuments, contactsToDocuments } from './knowledge/wallet.js';
-export type { WalletTx, Contact } from './knowledge/wallet.js';
-export { merchantsToDocuments } from './knowledge/merchants.js';
-export type { Merchant } from './knowledge/merchants.js';
-export { createBtcMapToolSource } from './knowledge/btc-map.js';
-export type {
-  BtcMapToolOptions,
-  BtcMapMerchant,
-  BtcMapFetch,
-  LocationProvider,
-  LatLng,
-} from './knowledge/btc-map.js';
+// ── Domain packs ─────────────────────────────────────────────────────────────
+// Each has its own subpath (`@kaleidorg/mind/kaleidoswap`, `/lsps1`,
+// `/submarine`, `/bitrefill`, `/flashnet`, `/knowledge`). The root re-exports
+// them for compatibility; 1.0 drops these re-exports.
+export * from './kaleidoswap/index.js';
+export * from './lsps1/index.js';
+export * from './submarine/index.js';
+export * from './bitrefill/index.js';
+export * from './flashnet/index.js';
+export * from './knowledge/index.js';
 
 export { Engine } from './engine.js';
 export type { EngineOptions, AgenticOptions, AgenticResult, ComposedSkill } from './engine.js';

package/src/kaleidoswap/contract.test.ts

@@ -6,6 +6,7 @@ import {
   getKaleidoswapTool,
   kaleidoswapTools,
   bindKaleidoswapTools,
+  normalizeKaleidoswapArgs,
   type KaleidoswapHandler,
 } from './contract.js';
 
@@ -109,10 +110,14 @@ describe('bindKaleidoswapTools', () => {
     expect(pairs?.requiresConfirmation).toBeFalsy();
   });
 
-  it('dispatches execute() to the right handler with args', async () => {
+  it('dispatches execute() with kaleido-mcp args plus the legacy aliases', async () => {
     const src = bindKaleidoswapTools(echoHandlers());
-    const r = await src.execute('kaleidoswap_get_quote', { from_asset: 'BTC', to_asset: 'USDT', amount: 100_000 });
-    expect(r).toMatchObject({ ok: true, tool: 'get_quote', args: { from_asset: 'BTC', amount: 100_000 } });
+    const r = await src.execute('kaleidoswap_get_quote', { from_asset_id: 'BTC', to_asset_id: 'USDT', from_amount: 0.001 });
+    expect(r).toMatchObject({
+      ok: true,
+      tool: 'get_quote',
+      args: { from_asset_id: 'BTC', to_asset_id: 'USDT', from_amount: 0.001, from_asset: 'BTC', to_asset: 'USDT', amount: 100_000 },
+    });
   });
 
   it('throws when a handler is missing and allowMissing is false', () => {
@@ -142,3 +147,27 @@ describe('bindKaleidoswapTools', () => {
     expect(src.id).toBe('maker-prod');
   });
 });
+
+describe('normalizeKaleidoswapArgs', () => {
+  it('maps a display-unit quote to the legacy sats amount', () => {
+    expect(normalizeKaleidoswapArgs('kaleidoswap_get_quote', { from_asset_id: 'BTC', to_asset_id: 'USDT', from_amount: 0.0005 }))
+      .toMatchObject({ from_asset: 'BTC', to_asset: 'USDT', amount: 50_000 });
+  });
+
+  it('keeps RGB amounts in display units and marks a buy-side amount', () => {
+    expect(normalizeKaleidoswapArgs('kaleidoswap_get_quote', { from_asset_id: 'BTC', to_asset_id: 'USDT', to_amount: 10 }))
+      .toMatchObject({ amount: 10, amount_side: 'to' });
+  });
+
+  it('maps a legacy sats quote to display units', () => {
+    expect(normalizeKaleidoswapArgs('kaleidoswap_get_quote', { from_asset: 'BTC', to_asset: 'USDT', amount: 100_000 }))
+      .toMatchObject({ from_asset_id: 'BTC', to_asset_id: 'USDT', from_amount: 0.001 });
+    expect(normalizeKaleidoswapArgs('kaleidoswap_get_quote', { from_asset: 'USDT', to_asset: 'BTC', amount: 25 }))
+      .toMatchObject({ from_amount: 25 });
+  });
+
+  it('aliases rfq_id/quote_id and payment_hash/atomic_id', () => {
+    expect(normalizeKaleidoswapArgs('kaleidoswap_atomic_init', { rfq_id: 'r1' })).toMatchObject({ quote_id: 'r1' });
+    expect(normalizeKaleidoswapArgs('kaleidoswap_atomic_status', { atomic_id: 'h1' })).toMatchObject({ payment_hash: 'h1' });
+  });
+});

package/src/kaleidoswap/contract.ts

@@ -70,14 +70,16 @@ export const KALEIDOSWAP_TOOLS: KaleidoswapToolDef[] = [
 
   t('market',
     'kaleidoswap_get_quote',
-    'Get an executable quote for swapping a specific amount on one pair. Returns a quote id (use it with atomic_init), the expected receive amount, fees, slippage, and how long the quote is valid for. Re-quote rather than reusing a stale id.',
+    'Get an executable quote for one pair. Amounts are DISPLAY units (0.0005 = 0.0005 BTC = 50,000 sats). Give exactly one of from_amount (sell a fixed input) or to_amount (buy a fixed output). Returns rfq_id, from_asset/to_asset with amount_display and amount_raw, price and expires_at (~60s).',
     {
-      from_asset: { type: 'string', description: 'Asset to spend, e.g. "BTC" or "USDT".' },
-      to_asset:   { type: 'string', description: 'Asset to receive, e.g. "USDT" or "BTC".' },
-      amount:     { type: 'number', description: 'Amount of from_asset to swap. BTC is in satoshis; RGB assets use their asset-defined precision.' },
-      side:       { type: 'string', enum: ['buy', 'sell'], description: 'Default "sell" (you sell from_asset). Use "buy" only when from_asset is the quote currency you spend to acquire to_asset.' },
+      from_asset_id: { type: 'string', description: "Asset to sell: ticker ('BTC', 'USDT') or RGB id ('rgb:…')." },
+      to_asset_id:   { type: 'string', description: "Asset to buy: ticker ('USDT', 'BTC') or RGB id ('rgb:…')." },
+      from_layer:    { type: 'string', description: "Optional: 'BTC_LN', 'RGB_LN', 'BTC_SPARK'. Derived from the asset when omitted." },
+      to_layer:      { type: 'string', description: "Optional: 'RGB_LN', 'BTC_LN', 'BTC_SPARK'. Derived from the asset when omitted." },
+      from_amount:   { type: 'number', description: 'Amount to SELL in display units (e.g. 0.001 BTC, 10 USDT).' },
+      to_amount:     { type: 'number', description: 'Amount to BUY in display units (e.g. 10 USDT).' },
     },
-    ['from_asset', 'to_asset', 'amount']),
+    ['from_asset_id', 'to_asset_id']),
 
   t('market',
     'kaleidoswap_get_nodeinfo',
@@ -86,30 +88,36 @@ export const KALEIDOSWAP_TOOLS: KaleidoswapToolDef[] = [
   // ─── atomic (the trust-minimised swap chain — used by the recipe) ───────
   t('atomic',
     'kaleidoswap_atomic_init',
-    "Initialise an atomic swap from a quote. Requires the receiver's RGB/LN invoice so the maker can lock the outgoing leg. SPEND: confirmation-gated. Returns the maker's invoice for the user to pay and an atomic id to track.",
+    'Start an atomic swap from a fresh quote. SPEND: confirmation-gated. Pass the quote rfq_id, both asset ids and the quote legs\' amount_raw values unchanged. Returns swapstring, payment_hash and access_token (keep it for status).',
     {
-      quote_id:        { type: 'string', description: 'The quote id from kaleidoswap_get_quote.' },
-      receive_invoice: { type: 'string', description: "The user's RGB or Lightning invoice for to_asset, created on the user's own node." },
+      rfq_id:          { type: 'string', description: 'rfq_id from kaleidoswap_get_quote.' },
+      from_asset_id:   { type: 'string', description: 'from_asset.asset_id from the quote.' },
+      from_amount_raw: { type: 'integer', description: 'from_asset.amount_raw from the quote, unchanged.' },
+      to_asset_id:     { type: 'string', description: 'to_asset.asset_id from the quote.' },
+      to_amount_raw:   { type: 'integer', description: 'to_asset.amount_raw from the quote, unchanged.' },
     },
-    ['quote_id', 'receive_invoice'],
+    ['rfq_id', 'from_asset_id', 'from_amount_raw', 'to_asset_id', 'to_amount_raw'],
     /* spend */ true),
 
   t('atomic',
     'kaleidoswap_atomic_execute',
-    "Tell the maker to release the receive leg now that the user has paid the maker's invoice. SPEND: confirmation-gated (committing the swap). Returns an updated atomic status.",
+    'Confirm the swap after rln_atomic_taker whitelisted the swapstring. SPEND: confirmation-gated. taker_pubkey is the pubkey from rln_get_node_info.',
     {
-      atomic_id: { type: 'string', description: 'The atomic id from kaleidoswap_atomic_init.' },
+      swapstring:   { type: 'string', description: 'swapstring from kaleidoswap_atomic_init.' },
+      taker_pubkey: { type: 'string', description: 'Node pubkey from rln_get_node_info.' },
+      payment_hash: { type: 'string', description: 'payment_hash from kaleidoswap_atomic_init.' },
     },
-    ['atomic_id'],
+    ['swapstring', 'taker_pubkey', 'payment_hash'],
     /* spend */ true),
 
   t('atomic',
     'kaleidoswap_atomic_status',
-    'Poll the status of an atomic swap — pending_payment / paid / settling / completed / failed / expired. Use this in a loop after execute until it terminates.',
+    'Poll an atomic swap by payment_hash: Waiting → Pending → Succeeded | Expired | Failed.',
     {
-      atomic_id: { type: 'string', description: 'The atomic id from kaleidoswap_atomic_init.' },
+      payment_hash: { type: 'string', description: 'payment_hash from kaleidoswap_atomic_init.' },
+      access_token: { type: 'string', description: 'access_token from kaleidoswap_atomic_init, when the host needs it.' },
     },
-    ['atomic_id']),
+    ['payment_hash']),
 
   // ─── liquidity (buy a NEW channel pre-loaded with an asset — onboarding) ──
   t('liquidity',
@@ -157,6 +165,46 @@ export function kaleidoswapTools(
   return KALEIDOSWAP_TOOLS.filter((x) => groups.has(x.group));
 }
 
+const isBtc = (asset: unknown) => typeof asset === 'string' && /^(btc|sats?)$/i.test(asset.trim());
+
+/**
+ * Map kaleido-mcp argument names onto the pre-0.9 contract names (and back), so
+ * one call shape works on every surface and older host handlers keep working.
+ * Canonical names win; legacy names are only filled in when absent. The legacy
+ * quote `amount` is sats for BTC and display units otherwise.
+ */
+export function normalizeKaleidoswapArgs(name: string, args: Record<string, unknown>): Record<string, unknown> {
+  const a: Record<string, unknown> = { ...args };
+  const alias = (canonical: string, legacy: string) => {
+    if (a[canonical] == null && a[legacy] != null) a[canonical] = a[legacy];
+    if (a[legacy] == null && a[canonical] != null) a[legacy] = a[canonical];
+  };
+  if (name === 'kaleidoswap_get_quote') {
+    if (a.from_asset_id == null && a.from_asset != null) a.from_asset_id = a.from_asset;
+    if (a.to_asset_id == null && a.to_asset != null) a.to_asset_id = a.to_asset;
+    if (a.from_amount == null && a.to_amount == null && a.amount != null) {
+      const side = a.amount_side === 'to' || a.side === 'buy' ? 'to' : 'from';
+      const asset = side === 'to' ? a.to_asset_id : a.from_asset_id;
+      const display = isBtc(asset) ? Number(a.amount) / 1e8 : Number(a.amount);
+      a[side === 'to' ? 'to_amount' : 'from_amount'] = display;
+    }
+    a.from_asset ??= a.from_asset_id;
+    a.to_asset ??= a.to_asset_id;
+    if (a.amount == null) {
+      const toSide = a.from_amount == null && a.to_amount != null;
+      const display = Number(toSide ? a.to_amount : a.from_amount);
+      const asset = toSide ? a.to_asset_id : a.from_asset_id;
+      if (Number.isFinite(display)) a.amount = isBtc(asset) ? Math.round(display * 1e8) : display;
+      if (toSide) a.amount_side = 'to';
+    }
+  } else if (name === 'kaleidoswap_atomic_init') {
+    alias('rfq_id', 'quote_id');
+  } else if (name === 'kaleidoswap_atomic_execute' || name === 'kaleidoswap_atomic_status') {
+    alias('payment_hash', 'atomic_id');
+  }
+  return a;
+}
+
 /** A handler bound to one contract tool. Args validated by JSON schema upstream. */
 export type KaleidoswapHandler = (args: Record<string, unknown>) => Promise<unknown>;
 
@@ -199,7 +247,7 @@ export function bindKaleidoswapTools(
       description: def.description,
       parameters: def.parameters,
       requiresConfirmation: def.requiresConfirmation,
-      handler,
+      handler: (args) => handler(normalizeKaleidoswapArgs(def.name, args)),
     });
   }
   return new InProcessToolSource(opts.id ?? 'kaleidoswap', bound);

package/src/kaleidoswap/index.ts

@@ -0,0 +1,20 @@
+/** KaleidoSwap maker: tool contract and recipes (price, atomic swap, channel order, buy asset channel). */
+export {
+  KALEIDOSWAP_TOOLS,
+  KALEIDOSWAP_SPEND_TOOLS,
+  isKaleidoswapSpendTool,
+  normalizeKaleidoswapArgs,
+  getKaleidoswapTool,
+  kaleidoswapTools,
+  bindKaleidoswapTools,
+} from './contract.js';
+export type {
+  KaleidoswapGroup,
+  KaleidoswapToolDef,
+  KaleidoswapHandler,
+  BindKaleidoswapOptions,
+} from './contract.js';
+export { kaleidoswapPriceRecipe } from '../recipe/kaleidoswap-price.js';
+export { kaleidoswapAtomicRecipe } from '../recipe/kaleidoswap-atomic.js';
+export { kaleidoswapChannelOrderRecipe, extractChannelOrder } from '../recipe/kaleidoswap-channel-order.js';
+export { buyAssetChannelRecipe, extractBuyAsset } from '../recipe/buy-asset-channel.js';

package/src/knowledge/index.ts

@@ -0,0 +1,14 @@
+/** Knowledge packs and corpus adapters for RAG, and the BTC Map merchant tool. */
+export { BITCOIN_COPILOT_DOCS } from './bitcoin-copilot.js';
+export { walletHistoryToDocuments, contactsToDocuments } from './wallet.js';
+export type { WalletTx, Contact } from './wallet.js';
+export { merchantsToDocuments } from './merchants.js';
+export type { Merchant } from './merchants.js';
+export { createBtcMapToolSource } from './btc-map.js';
+export type {
+  BtcMapToolOptions,
+  BtcMapMerchant,
+  BtcMapFetch,
+  LocationProvider,
+  LatLng,
+} from './btc-map.js';

package/src/lsps1/index.ts

@@ -0,0 +1,13 @@
+/** LSPS1 Lightning Service Provider channel orders: tool contract. */
+export {
+  LSPS1_TOOLS,
+  LSPS1_SPEND_TOOLS,
+  isLsps1SpendTool,
+  getLsps1Tool,
+  bindLsps1Tools,
+} from './contract.js';
+export type {
+  Lsps1ToolDef,
+  Lsps1Handler,
+  BindLsps1Options,
+} from './contract.js';

package/src/providers/types.ts

@@ -2,9 +2,9 @@
  * LLMProvider — the only thing the Engine talks to for inference.
  *
  * Each host implements this over its own LLM transport:
- *   - rate (mobile): wraps @qvac/sdk completion() (local or P2P-delegated)
- *   - desktop-app:   wraps @qvac/sdk completion() in Node
- *   - kaleidoagent:  could wrap Anthropic/OpenAI
+ *   - QVAC on-device (rate, desktop sidecar, CLI): `@kaleidorg/mind/qvac`
+ *   - any OpenAI-compatible server (Ollama, LM Studio, hosted APIs):
+ *     `@kaleidorg/mind/openai`
  *
  * The core package never imports any LLM SDK — it only depends on this
  * interface, so it stays pure TS and bundles anywhere.

package/src/qvac/index.ts

@@ -75,11 +75,3 @@ export {
   type VoiceTranscriptEvent,
 } from './assistant.js';
 
-export {
-  allowListFirewall,
-  denyListFirewall,
-  firewallFromKeyList,
-  buildDelegateConfig,
-  type ProviderFirewall,
-  type DelegateConfig,
-} from './delegate.js';

package/src/qvac/provider.test.ts

@@ -96,23 +96,6 @@ describe('createQvacProvider.runTurn', () => {
     expect(calls[0].generationParams).toBeUndefined();
   });
 
-  it('caps thinking by tokens — cancels the run and returns a fallback', async () => {
-    const cancel = vi.fn(async () => {});
-    const { fn } = fakeCompletion(
-      { contentText: '', toolCalls: [], raw: { fullText: '' }, stopReason: 'cancelled' },
-      [{ type: 'thinkingDelta', text: 'z'.repeat(400) }], // ~100 tokens, budget 4 (+ backstop headroom)
-    );
-    const p = createQvacProvider({
-      completion: fn as any,
-      cancel: cancel as any,
-      getModelId: () => 'm1',
-      maxThinkingTokens: 4,
-    });
-    const out = await p.runTurn({ messages: [{ role: 'user', content: 'think hard' }], tools: [] });
-    expect(cancel).toHaveBeenCalledWith({ requestId: 'req-1' });
-    expect(out.text).toMatch(/thinking budget/i);
-  });
-
   it('sends the thinking cap as the SDK reasoning_budget', async () => {
     const { fn, calls } = fakeCompletion({ contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' } });
     const p = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1', maxThinkingTokens: 128 });
@@ -140,6 +123,23 @@ describe('createQvacProvider.runTurn', () => {
     expect(deleted).toEqual([{ kvCacheKey: 'run-1' }]);
   });
 
+  it('retries a turn without reasoning when the tool grammar rejects the inserted </think>', async () => {
+    const calls: any[] = [];
+    const fn = (params: any) => {
+      calls.push(params);
+      if (calls.length === 1) throw new Error('Unexpected empty grammar stack after accepting piece: </think> (248069)');
+      return { requestId: 'req-2', events: (async function* () {})(), final: Promise.resolve({ contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' } }) };
+    };
+    const p = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1', maxThinkingTokens: 128 });
+    const out = await p.runTurn({ messages: [{ role: 'user', content: 'x' }], tools: [] });
+    expect(out.text).toBe('ok');
+    expect(calls.map((c) => c.generationParams?.reasoning_budget)).toEqual([128, 0]);
+    await expect(
+      createQvacProvider({ completion: (() => { throw new Error('boom'); }) as any, cancel: noopCancel, getModelId: () => 'm1' })
+        .runTurn({ messages: [{ role: 'user', content: 'x' }], tools: [] }),
+    ).rejects.toThrow('boom');
+  });
+
   it('keeps the reasoning budget below the output cap', async () => {
     const { fn, calls } = fakeCompletion({ contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' } });
     const p = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1', defaultMaxTokens: 512, maxThinkingTokens: 512 });

package/src/qvac/provider.ts

@@ -10,11 +10,10 @@
  * desktop sidecar its lazily-loaded SDK facade — which also makes this provider
  * unit-testable with a fake completion.
  *
- * The host owns model lifecycle (load/unload, local-vs-delegated) and passes
+ * The host owns model lifecycle (load/unload) and passes
  * `getModelId()` so a turn always runs against the currently-loaded model.
  * Tools are forwarded by schema only; the Engine executes them via its
- * ToolSources, so signing/spending stays on the host even when inference is
- * delegated to a desktop peer.
+ * ToolSources, so signing and spending stay on the host.
  */
 import type * as QvacSdk from '@qvac/sdk';
 import type { InferenceMetrics, LLMProvider, TurnInput, TurnOutput } from '../providers/types.js';
@@ -44,15 +43,16 @@ export interface QvacProviderOptions {
   /**
    * Cap `<think>` reasoning at this many TOKENS (not seconds — tok/s varies).
    * Sent as the SDK's `reasoning_budget`, so the model closes its reasoning and
-   * answers. If the stream still runs well past it, the run is cancelled and a
-   * short fallback is returned instead of hanging on "Thinking…". Omit for
-   * unlimited reasoning.
+   * answers. Kept below the output cap. Omit for unlimited reasoning.
    */
   maxThinkingTokens?: number;
   /**
-   * Keep each agentic run in a QVAC KV-cache session (`kvCache: sessionKey`),
-   * so calls after the first send only the new message instead of re-reading
-   * the whole prompt. Needs `deleteCache` to drop the session at the end.
+   * Experimental. Keep each agentic run in a QVAC KV-cache session
+   * (`kvCache: sessionKey`), so calls after the first send only the new
+   * message instead of re-reading the whole prompt. Needs `deleteCache` to
+   * drop the session at the end. In the rgb-agent eval (Qwen3.5 2B) it cut
+   * time to first token from ~7 s to ~0.2 s, but the model copied a Lightning
+   * invoice correctly in 4/10 runs with it vs 10/10 without. Off by default.
    */
   sessionCache?: boolean;
   /** The SDK's `deleteCache` (injected); used with `sessionCache`. */
@@ -76,16 +76,17 @@ export interface QvacTurnInput extends TurnInput {
   onStats?: (stats: QvacTurnStats) => void;
 }
 
-/** Shown when a turn is cut off because it blew its thinking-token budget. */
-const THINKING_BUDGET_FALLBACK =
-  'I spent my whole thinking budget on that one without landing an answer. ' +
-  'Try asking again, more specifically.';
+/**
+ * llama.cpp's tool-call grammar can reject the `</think>` it inserts when a
+ * reasoning budget runs out ("Unexpected empty grammar stack after accepting
+ * piece: </think>"), which aborts the turn.
+ */
+function isReasoningGrammarError(err: unknown): boolean {
+  return /empty grammar stack/i.test(err instanceof Error ? err.message : String(err));
+}
 
 export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
-  return {
-    name: 'qvac',
-
-    async runTurn(input: QvacTurnInput): Promise<TurnOutput> {
+  const runTurnOnce = async (input: QvacTurnInput): Promise<TurnOutput> => {
       const modelId = options.getModelId();
       if (!modelId) throw new Error('QVAC model not loaded');
 
@@ -153,24 +154,12 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
       const result = await consumeRun(run, {
         onToken: input.onToken,
         onThinking: input.onThinking ?? options.onThinking,
-        // Backstop only: the SDK enforces the budget itself, and our count is a
-        // char-based estimate, so leave headroom before cancelling.
-        maxThinkingTokens:
-          maxThinkingTokens === undefined ? undefined : Math.ceil(maxThinkingTokens * 1.25) + 32,
-        // Cancel the in-flight run the moment the thinking budget is blown — the
-        // SDK keeps generating otherwise. Fire-and-forget; `final` then resolves.
-        onThinkingBudgetExceeded: () => {
-          void options.cancel({ requestId: run.requestId }).catch(() => {});
-        },
       });
 
       // Surface the real per-turn inference stats (backend device + throughput).
       if (result.stats) (input.onStats ?? options.onStats)?.(result.stats);
 
-      // A turn cut off mid-reasoning has no visible answer — return a short note
-      // instead of an empty bubble so the agentic loop ends cleanly.
-      const text =
-        result.text || (result.thinkingBudgetExceeded ? THINKING_BUDGET_FALLBACK : result.text);
+      const text = result.text;
       const promptTokens = result.stats?.promptTokens;
       const generated = result.stats?.generatedTokens;
       const totalTokens =
@@ -199,7 +188,7 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
       };
 
       const incomplete =
-        !result.text && result.toolCalls.length === 0 && (result.thinkingBudgetExceeded || !!result.truncated);
+        !result.text && result.toolCalls.length === 0 && !!result.truncated;
       return {
         text,
         rawContent: result.rawContent,
@@ -209,6 +198,19 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
         inference,
         ...(incomplete ? { incomplete: true } : {}),
       };
+  };
+
+  return {
+    name: 'qvac',
+
+    async runTurn(input: QvacTurnInput): Promise<TurnOutput> {
+      try {
+        return await runTurnOnce(input);
+      } catch (err) {
+        // Retry once without reasoning: no budget, so nothing to insert.
+        if (input.thinking === 'off' || !isReasoningGrammarError(err)) throw err;
+        return runTurnOnce({ ...input, thinking: 'off' });
+      }
     },
 
     async endSession(sessionKey: string): Promise<void> {

package/src/qvac/stream.ts

@@ -28,9 +28,10 @@ export interface StreamHandlers {
   /** The model's `<think>` reasoning, streamed separately. */
   onThinking?: (token: string) => void;
   /**
-   * Stop the run once `<think>` reasoning exceeds this many tokens (estimated
-   * from characters). A backstop for the SDK's own `reasoning_budget`. Omit for
-   * unlimited reasoning.
+   * Stop forwarding once `<think>` reasoning exceeds this many tokens
+   * (estimated from characters) and call `onThinkingBudgetExceeded`. The QVAC
+   * provider uses the SDK's `reasoning_budget` instead; this is for callers
+   * driving `completion()` themselves.
    */
   maxThinkingTokens?: number;
   /**

package/src/qvac/voice.ts

@@ -4,7 +4,7 @@
  * injected (type-only `@qvac/sdk` import, erased at build) so this carries no
  * runtime SDK dependency and is unit-testable with fakes.
  *
- * The host still owns model lifecycle (download, load, local-vs-delegated) and
+ * The host still owns model lifecycle (download, load) and
  * audio I/O (mic capture, playback). It passes the loaded model-id resolvers;
  * this module does the SDK calls + the text gating that must be identical
  * everywhere (payment-string redaction, U+0060 refusal, file:// stripping).

package/src/recipe/asset-send.ts

@@ -69,7 +69,7 @@ export const assetSendRecipe: Recipe = {
     tool: 'rln_send_asset',
     args: (ctx: RecipeContext) => {
       const contact = ctx.results.contact as { ln_address?: string } | undefined;
-      return { asset: ctx.slots.asset, amount: ctx.slots.amount, to: contact?.ln_address ?? ctx.slots.recipient };
+      return { asset_id: ctx.slots.asset, amount: ctx.slots.amount, recipient_id: contact?.ln_address ?? ctx.slots.recipient };
     },
   },
   summary: (ctx) => {

package/src/recipe/recipe.test.ts

@@ -257,7 +257,7 @@ describe('runRecipe — asset send', () => {
     const res = await runRecipe(assetSendRecipe, 'send 10 usdt to bob', { provider: approve, tools, onConfirm });
     expect(res.status).toBe('done');
     expect(onConfirm).toHaveBeenCalledOnce();
-    expect(sent[0]).toEqual({ asset: 'USDT', amount: 10, to: 'bob@x.com' });
+    expect(sent[0]).toEqual({ asset_id: 'USDT', amount: 10, recipient_id: 'bob@x.com' });
   });
 });