@kaleidorg/mind 0.8.1 → 0.9.0

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.

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 });

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,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',
@@ -153,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 =
@@ -199,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,

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"}

package/dist/qvac/delegate.js

@@ -1,53 +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).
- */
-function normalizeKeys(keys) {
-    return [...new Set([...keys].map((k) => k.trim()).filter(Boolean))];
-}
-/**
- * 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 function allowListFirewall(consumerPublicKeys) {
-    return { mode: 'allow', publicKeys: normalizeKeys(consumerPublicKeys) };
-}
-/** Deny these consumer public keys; everyone else may connect. */
-export function denyListFirewall(consumerPublicKeys) {
-    return { mode: 'deny', publicKeys: normalizeKeys(consumerPublicKeys) };
-}
-/**
- * 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 function firewallFromKeyList(raw) {
-    if (!raw)
-        return undefined;
-    const keys = raw.split(/[\s,]+/).map((k) => k.trim()).filter(Boolean);
-    return keys.length ? allowListFirewall(keys) : undefined;
-}
-/**
- * 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 function buildDelegateConfig(providerPublicKey, opts = {}) {
-    return {
-        providerPublicKey: providerPublicKey.trim(),
-        fallbackToLocal: opts.fallbackToLocal ?? false,
-        ...(opts.timeout != null ? { timeout: opts.timeout } : {}),
-        ...(opts.forceNewConnection != null ? { forceNewConnection: opts.forceNewConnection } : {}),
-    };
-}
-//# sourceMappingURL=delegate.js.map

package/dist/qvac/delegate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"delegate.js","sourceRoot":"","sources":["../../src/qvac/delegate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH,SAAS,aAAa,CAAC,IAAsB;IAC3C,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;AACtE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,kBAAoC;IACpE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAAE,CAAC;AAC1E,CAAC;AAED,kEAAkE;AAClE,MAAM,UAAU,gBAAgB,CAAC,kBAAoC;IACnE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAAE,CAAC;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAA8B;IAChE,IAAI,CAAC,GAAG;QAAE,OAAO,SAAS,CAAC;IAC3B,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACtE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC3D,CAAC;AAUD;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CACjC,iBAAyB,EACzB,IAAI,GAAkF,EAAE;IAExF,OAAO;QACL,iBAAiB,EAAE,iBAAiB,CAAC,IAAI,EAAE;QAC3C,eAAe,EAAE,IAAI,CAAC,eAAe,IAAI,KAAK;QAC9C,GAAG,CAAC,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1D,GAAG,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,kBAAkB,EAAE,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC5F,CAAC;AACJ,CAAC"}

package/src/qvac/delegate.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  allowListFirewall,
-  denyListFirewall,
-  firewallFromKeyList,
-  buildDelegateConfig,
-} from './delegate.js';
-
-describe('allowListFirewall', () => {
-  it('builds an allow-list, trimming + de-duping keys', () => {
-    expect(allowListFirewall([' k1 ', 'k2', 'k1', ''])).toEqual({
-      mode: 'allow',
-      publicKeys: ['k1', 'k2'],
-    });
-  });
-
-  it('is empty for no keys (caller must decide: open vs refuse)', () => {
-    expect(allowListFirewall([])).toEqual({ mode: 'allow', publicKeys: [] });
-  });
-});
-
-describe('denyListFirewall', () => {
-  it('builds a deny-list', () => {
-    expect(denyListFirewall(['bad'])).toEqual({ mode: 'deny', publicKeys: ['bad'] });
-  });
-});
-
-describe('firewallFromKeyList', () => {
-  it('parses comma/space/newline-separated keys into an allow-list', () => {
-    expect(firewallFromKeyList('k1, k2\nk3 k4')).toEqual({
-      mode: 'allow',
-      publicKeys: ['k1', 'k2', 'k3', 'k4'],
-    });
-  });
-
-  it('returns undefined for empty/missing input (advertise openly)', () => {
-    expect(firewallFromKeyList('')).toBeUndefined();
-    expect(firewallFromKeyList('   ')).toBeUndefined();
-    expect(firewallFromKeyList(null)).toBeUndefined();
-    expect(firewallFromKeyList(undefined)).toBeUndefined();
-  });
-});
-
-describe('buildDelegateConfig', () => {
-  it('defaults fallbackToLocal to false and trims the key', () => {
-    expect(buildDelegateConfig('  pk  ')).toEqual({
-      providerPublicKey: 'pk',
-      fallbackToLocal: false,
-    });
-  });
-
-  it('passes through fallbackToLocal, timeout, forceNewConnection when set', () => {
-    expect(
-      buildDelegateConfig('pk', { fallbackToLocal: true, timeout: 60000, forceNewConnection: true }),
-    ).toEqual({
-      providerPublicKey: 'pk',
-      fallbackToLocal: true,
-      timeout: 60000,
-      forceNewConnection: true,
-    });
-  });
-
-  it('omits optional fields that are not set', () => {
-    const cfg = buildDelegateConfig('pk', { fallbackToLocal: false });
-    expect('timeout' in cfg).toBe(false);
-    expect('forceNewConnection' in cfg).toBe(false);
-  });
-});

package/src/qvac/delegate.ts

@@ -1,73 +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[];
-}
-
-function normalizeKeys(keys: Iterable<string>): string[] {
-  return [...new Set([...keys].map((k) => k.trim()).filter(Boolean))];
-}
-
-/**
- * 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 function allowListFirewall(consumerPublicKeys: Iterable<string>): ProviderFirewall {
-  return { mode: 'allow', publicKeys: normalizeKeys(consumerPublicKeys) };
-}
-
-/** Deny these consumer public keys; everyone else may connect. */
-export function denyListFirewall(consumerPublicKeys: Iterable<string>): ProviderFirewall {
-  return { mode: 'deny', publicKeys: normalizeKeys(consumerPublicKeys) };
-}
-
-/**
- * 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 function firewallFromKeyList(raw: string | null | undefined): ProviderFirewall | undefined {
-  if (!raw) return undefined;
-  const keys = raw.split(/[\s,]+/).map((k) => k.trim()).filter(Boolean);
-  return keys.length ? allowListFirewall(keys) : 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 function buildDelegateConfig(
-  providerPublicKey: string,
-  opts: { fallbackToLocal?: boolean; timeout?: number; forceNewConnection?: boolean } = {},
-): DelegateConfig {
-  return {
-    providerPublicKey: providerPublicKey.trim(),
-    fallbackToLocal: opts.fallbackToLocal ?? false,
-    ...(opts.timeout != null ? { timeout: opts.timeout } : {}),
-    ...(opts.forceNewConnection != null ? { forceNewConnection: opts.forceNewConnection } : {}),
-  };
-}