@kaleidorg/mind 0.8.0 → 0.9.0

package/src/flashnet/index.ts

@@ -0,0 +1,14 @@
+/** Flashnet (Spark-native AMM): tool contract and swap recipe. */
+export {
+  FLASHNET_TOOLS,
+  FLASHNET_SPEND_TOOLS,
+  isFlashnetSpendTool,
+  getFlashnetTool,
+  bindFlashnetTools,
+} from './contract.js';
+export type {
+  FlashnetToolDef,
+  FlashnetHandler,
+  BindFlashnetOptions,
+} from './contract.js';
+export { flashnetSwapRecipe } from '../recipe/flashnet-swap.js';

package/src/funnel.mind.test.ts

@@ -17,6 +17,7 @@
  * Fully deterministic (no node/model/maker), so it runs in CI. Live tool
  * execution against a real node is the separate mcp.live.test.ts.
  */
+import type { FastIntent } from './fastpath/fastpath.js';
 import { describe, expect, it } from 'vitest';
 import { Funnel } from './funnel.js';
 import { ToolRegistry } from './tools/registry.js';
@@ -83,7 +84,7 @@ function searchMerchants(query: string): string {
  */
 function buildMind(
   provider: LLMProvider,
-  opts: { skills?: Skill[]; log?: (m: string) => void } = {},
+  opts: { skills?: Skill[]; log?: (m: string) => void; fastIntents?: FastIntent[] } = {},
 ): { funnel: Funnel; calls: Array<{ name: string; args: any }> } {
   const calls: Array<{ name: string; args: any }> = [];
   const tool = (name: string, response: any, spend = false) => ({
@@ -140,27 +141,21 @@ function buildMind(
   ]);
 
   return {
-    funnel: new Funnel({ provider, tools, recipes: DESKTOP_RECIPES, maxTurns: 8, skills: opts.skills, log: opts.log }),
+    funnel: new Funnel({ provider, tools, recipes: DESKTOP_RECIPES, maxTurns: 8, skills: opts.skills, log: opts.log, ...(opts.fastIntents ? { fastIntents: opts.fastIntents } : {}) }),
     calls,
   };
 }
 
 describe('desktop mind — balance', () => {
-  it('routes "what\'s my balance?" to the agentic tier and calls rln_get_balances', async () => {
-    const { funnel, calls } = buildMind(
-      scripted([
-        { text: '', toolCalls: [{ name: 'rln_get_balances', arguments: {} }] },
-        { text: 'You have 1,949,753 sats in Lightning.' },
-      ]),
-    );
+  it('answers "what\'s my balance?" on the fast path with rln_get_balances, no model', async () => {
+    const { funnel, calls } = buildMind(scripted([]));
 
     const res = await funnel.runTurn("what's my balance?");
 
-    expect(res.tier).toBe('agentic');
-    expect(calls.map((c) => c.name)).toContain('rln_get_balances');
-    const exec = res.toolCalls?.find((c) => c.name === 'rln_get_balances');
-    expect((exec?.result as { lightning_balance_sat?: number })?.lightning_balance_sat).toBe(1_949_753);
-    expect(res.text).toBeTruthy();
+    expect(res.tier).toBe('fast');
+    expect(calls.map((c) => c.name)).toEqual(['rln_get_balances']);
+    expect((res.data as { lightning_balance_sat?: number })?.lightning_balance_sat).toBe(1_949_753);
+    expect(res.text).toBe('On-chain: 100,000 sats spendable.\nLightning: 1,949,753 sats.');
   });
 });
 
@@ -359,7 +354,8 @@ describe('desktop mind — skill scoping (real skills)', () => {
         { text: '', toolCalls: [{ name: 'rln_get_balances', arguments: {} }] },
         { text: 'You have 1,949,753 sats.' },
       ]),
-      { skills: SKILLS, log: (m) => logs.push(m) },
+      // Fast path off, so the balance ask exercises skill scoping.
+      { skills: SKILLS, log: (m) => logs.push(m), fastIntents: [] },
     );
 
     const res = await funnel.runTurn("what's my balance?");

package/src/funnel.ts

@@ -22,6 +22,7 @@
 import { Engine } from './engine.js';
 import type { ToolCrushOptions } from './context/compress.js';
 import type { ToolRegistry } from './tools/registry.js';
+import { defaultRenderFast } from './fastpath/render.js';
 import { FastPath, WALLET_FAST_INTENTS } from './fastpath/fastpath.js';
 import type { FastIntent } from './fastpath/fastpath.js';
 import { RecipeRegistry, runRecipe } from './recipe/runner.js';
@@ -176,18 +177,6 @@ export interface FunnelOptions {
   topKRag?: number;
 }
 
-function defaultRenderFast(intent: string, r: any): string {
-  if (intent === 'balance') {
-    const sats = Number(r?.total_sats ?? 0);
-    const n = r?.layers?.length ?? 0;
-    return `You have ${sats.toLocaleString()} sats${n > 1 ? ` across ${n} layers` : ''}.`;
-  }
-  if (intent === 'address') {
-    return r?.address ? `Here's your receive address:\n\n\`${r.address}\`` : 'No address available right now.';
-  }
-  return `Bitcoin is $${Number(r?.price_usd ?? 0).toLocaleString()}.`;
-}
-
 export class Funnel {
   private readonly provider: LLMProvider;
   private readonly registry: ToolRegistry;
@@ -251,9 +240,16 @@ export class Funnel {
     // tool — a partial tool surface (e.g. desktop without the core aggregate
     // helpers) falls through to the agentic tier instead of erroring.
     const fast = this.fastPath.select(text);
-    if (fast && (await this.registry.getDef(fast.tool))) {
-      this.log(`tier=fast-path → ${fast.tool}`);
-      const r = await this.registry.execute(fast.tool, fast.args);
+    let fastTool: string | undefined;
+    for (const name of fast?.tools ?? []) {
+      if (await this.registry.getDef(name)) {
+        fastTool = name;
+        break;
+      }
+    }
+    if (fast && fastTool) {
+      this.log(`tier=fast-path → ${fastTool}`);
+      const r = await this.registry.execute(fastTool, fast.args);
       return { text: this.renderFast(fast.intent.name, r), tier: 'fast', route: fast.intent.name, intent: fast.intent.name, data: r };
     }
 

package/src/index.ts

@@ -71,102 +71,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 +131,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/index.ts

@@ -0,0 +1,19 @@
+/** KaleidoSwap maker: tool contract and recipes (price, atomic swap, channel order, buy asset channel). */
+export {
+  KALEIDOSWAP_TOOLS,
+  KALEIDOSWAP_SPEND_TOOLS,
+  isKaleidoswapSpendTool,
+  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.
@@ -23,6 +23,17 @@ export interface TurnInput {
    * empty or the provider has no such control.
    */
   toolChoice?: ToolChoice;
+  /**
+   * `'off'` asks the provider to skip reasoning for this turn (e.g. a forced
+   * tool call). Ignored by providers without reasoning control.
+   */
+  thinking?: 'off';
+  /**
+   * Same value on every call of one agentic run, whose history only grows.
+   * Providers with a session cache (QVAC `kvCache`) can then send only the new
+   * message instead of the whole prompt.
+   */
+  sessionKey?: string;
   /** Visible content tokens as they stream. */
   onToken?: (token: string) => void;
   signal?: AbortSignal;
@@ -82,6 +93,8 @@ export interface LLMProvider {
   readonly name: string;
   /** Run one completion turn. */
   runTurn(input: TurnInput): Promise<TurnOutput>;
+  /** Drop whatever the provider cached for `sessionKey` (end of an agentic run). */
+  endSession?(sessionKey: string): Promise<void>;
   /** Cancel an in-flight turn by request id, if the provider supports it. */
   cancel?(requestId: string): Promise<void>;
 }

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 });
@@ -120,6 +103,26 @@ describe('createQvacProvider.runTurn', () => {
     expect(calls[0].generationParams).toEqual({ reasoning_budget: 128 });
   });
 
+  it("sends reasoning_budget 0 when a turn asks for thinking 'off'", async () => {
+    const { fn, calls } = fakeCompletion({ contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' } });
+    const p = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1', maxThinkingTokens: 128 });
+    await p.runTurn({ messages: [{ role: 'user', content: 'x' }], tools: [], thinking: 'off' });
+    expect(calls[0].generationParams).toEqual({ reasoning_budget: 0 });
+  });
+
+  it('uses the session key as kvCache when sessionCache is on, and deletes it at the end', async () => {
+    const { fn, calls } = fakeCompletion({ contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' } });
+    const deleted: unknown[] = [];
+    const on = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1', sessionCache: true, deleteCache: (async (p: unknown) => void deleted.push(p)) as any });
+    const off = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1' });
+    await on.runTurn({ messages: [{ role: 'user', content: 'x' }], tools: [], sessionKey: 'run-1' });
+    await off.runTurn({ messages: [{ role: 'user', content: 'x' }], tools: [], sessionKey: 'run-1' });
+    await on.endSession!('run-1');
+    expect(calls[0].kvCache).toBe('run-1');
+    expect(calls[1].kvCache).toBeUndefined();
+    expect(deleted).toEqual([{ kvCacheKey: 'run-1' }]);
+  });
+
   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';
@@ -24,6 +23,7 @@ import { toQvacTools } from './tools.js';
 
 type CompletionFn = typeof QvacSdk.completion;
 type CancelFn = typeof QvacSdk.cancel;
+type DeleteCacheFn = typeof QvacSdk.deleteCache;
 
 export interface QvacProviderOptions {
   /** The SDK's `completion` (injected — see module docs). */
@@ -43,11 +43,20 @@ 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;
+  /**
+   * 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`. */
+  deleteCache?: DeleteCacheFn;
   /** Stream the model's `<think>` reasoning, when a host wants to surface it. */
   onThinking?: (token: string) => void;
   /**
@@ -67,11 +76,6 @@ 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.';
-
 export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
   return {
     name: 'qvac',
@@ -96,7 +100,7 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
       const predict = input.maxTokens ?? options.defaultMaxTokens;
       // A thinking budget at or above the output cap never binds: the model can
       // spend the whole turn reasoning and return no answer. Keep half for it.
-      const thinkingCap = input.maxThinkingTokens ?? options.maxThinkingTokens;
+      const thinkingCap = input.thinking === 'off' ? 0 : (input.maxThinkingTokens ?? options.maxThinkingTokens);
       const maxThinkingTokens =
         thinkingCap !== undefined && predict !== undefined && thinkingCap >= predict
           ? Math.floor(predict / 2)
@@ -119,6 +123,7 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
         // Split `<think>` into separate thinkingDelta events so reasoning never
         // pollutes the visible answer.
         captureThinking: true,
+        ...(options.sessionCache && input.sessionKey ? { kvCache: input.sessionKey } : {}),
         ...(generationParams ? { generationParams } : {}),
         ...(tools ? { tools } : {}),
       } as unknown as Parameters<CompletionFn>[0]);
@@ -143,24 +148,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 =
@@ -189,7 +182,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,
@@ -201,6 +194,15 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
       };
     },
 
+    async endSession(sessionKey: string): Promise<void> {
+      if (!options.sessionCache || !options.deleteCache) return;
+      try {
+        await options.deleteCache({ kvCacheKey: sessionKey });
+      } catch (err) {
+        console.warn('[qvac] deleteCache failed:', err);
+      }
+    },
+
     async cancel(requestId: string): Promise<void> {
       // The cancel only lands once the server has begun the request; a same-tick
       // cancel may race the begin and is logged as a no-match by the SDK.

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/submarine/index.ts

@@ -0,0 +1,17 @@
+/** KaleidoSwap /v2 submarine swaps (pay Lightning from Liquid): tool contract and recipe. */
+export {
+  SUBMARINE_TOOLS,
+  SUBMARINE_SPEND_TOOLS,
+  SUBMARINE_FROM_ASSETS,
+  isSubmarineSpendTool,
+  getSubmarineTool,
+  formatSubmarineAmount,
+  bindSubmarineTools,
+} from './contract.js';
+export type {
+  SubmarineToolDef,
+  SubmarineFromAsset,
+  SubmarineHandler,
+  BindSubmarineOptions,
+} from './contract.js';
+export { submarinePayRecipe, extractSubmarinePay } from '../recipe/submarine-pay.js';

package/src/tools/in-process.ts

@@ -2,8 +2,8 @@
  * InProcessToolSource — tools whose handlers run in the same process.
  *
  * Used by the mobile wallet: the handlers call the device's wallet adapters
- * (Spark / Arkade / RGB) directly, so signing happens on the phone even when
- * the model's inference is delegated to a desktop over P2P.
+ * (Spark / Arkade / RGB) directly, so signing happens on the device even when
+ * the model runs on a remote server.
  */
 
 import type { ToolDef } from '../types.js';

package/dist/qvac/delegate.d.ts

@@ -1,50 +0,0 @@
-/**
- * Delegation helpers — the provider firewall (who may connect) and the
- * consumer-side delegate config. Pure data builders (no `@qvac/sdk` import) so
- * they stay shared + testable; the host passes the result to
- * `startQVACProvider({ firewall })` / `loadModel({ delegate })`.
- *
- * P2P delegation exists in @qvac/sdk 0.13–0.18 only; 0.19 removed both calls.
- *
- * Security note: a QVAC provider is reachable by anyone who learns its
- * Hyperswarm public key. Advertising with no firewall means any such peer can
- * run inference on your machine. Use {@link allowListFirewall} so a desktop
- * provider serves ONLY its paired phone(s).
- */
-/** Firewall for `startQVACProvider` — restrict who may delegate to this provider. */
-export interface ProviderFirewall {
-    mode: 'allow' | 'deny';
-    publicKeys: string[];
-}
-/**
- * Allow ONLY these consumer public keys to delegate (zero-trust). Pass the
- * paired phone(s)' public keys so no one else can use the desktop brain even if
- * they learn its public key.
- */
-export declare function allowListFirewall(consumerPublicKeys: Iterable<string>): ProviderFirewall;
-/** Deny these consumer public keys; everyone else may connect. */
-export declare function denyListFirewall(consumerPublicKeys: Iterable<string>): ProviderFirewall;
-/**
- * Parse a comma/space/newline-separated key list (e.g. from an env var or a
- * pairing store) into an allow-list firewall, or `undefined` when none are
- * configured — the caller then advertises openly and should warn.
- */
-export declare function firewallFromKeyList(raw: string | null | undefined): ProviderFirewall | undefined;
-/** Consumer-side config for `loadModel({ delegate })`. */
-export interface DelegateConfig {
-    providerPublicKey: string;
-    fallbackToLocal: boolean;
-    timeout?: number;
-    forceNewConnection?: boolean;
-}
-/**
- * Build the `delegate` config for a delegated `loadModel`. `fallbackToLocal`
- * defaults to false (the host owns recovery), matching rate's existing
- * LLM/Whisper/TTS delegated loads.
- */
-export declare function buildDelegateConfig(providerPublicKey: string, opts?: {
-    fallbackToLocal?: boolean;
-    timeout?: number;
-    forceNewConnection?: boolean;
-}): DelegateConfig;
-//# sourceMappingURL=delegate.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../../src/qvac/delegate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,qFAAqF;AACrF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAMD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,gBAAgB,CAExF;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,gBAAgB,CAEvF;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,gBAAgB,GAAG,SAAS,CAIhG;AAED,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,iBAAiB,EAAE,MAAM,EACzB,IAAI,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAO,GACvF,cAAc,CAOhB"}