@kaleidorg/mind 0.3.0 → 0.5.0

package/src/qvac/voice.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createQvacVoice } from './voice.js';
+
+describe('createQvacVoice.transcribeAudio', () => {
+  it('strips the file:// prefix and passes a plain path to the SDK', async () => {
+    const transcribe = vi.fn(async () => 'hello world');
+    const voice = createQvacVoice({
+      transcribe: transcribe as any,
+      textToSpeech: (() => {}) as any,
+      getWhisperModelId: () => 'whisper-1',
+      getTtsModelId: () => null,
+    });
+    const text = await voice.transcribeAudio('file:///tmp/clip.wav');
+    expect(text).toBe('hello world');
+    expect(transcribe).toHaveBeenCalledWith({ modelId: 'whisper-1', audioChunk: '/tmp/clip.wav' });
+  });
+
+  it('throws when no Whisper model is loaded', async () => {
+    const voice = createQvacVoice({
+      transcribe: (() => { throw new Error('nope'); }) as any,
+      textToSpeech: (() => {}) as any,
+      getWhisperModelId: () => null,
+      getTtsModelId: () => null,
+    });
+    await expect(voice.transcribeAudio('/tmp/clip.wav')).rejects.toThrow(/not loaded/);
+  });
+});
+
+describe('createQvacVoice.synthesizeSpeech', () => {
+  function ttsReturning(pcm: number[]) {
+    const calls: any[] = [];
+    const fn = (params: any) => {
+      calls.push(params);
+      return { buffer: Promise.resolve(pcm) };
+    };
+    return { fn, calls };
+  }
+
+  it('returns null when no TTS model is loaded', async () => {
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: (() => { throw new Error('should not run'); }) as any,
+      getWhisperModelId: () => null,
+      getTtsModelId: () => null,
+    });
+    expect(await voice.synthesizeSpeech('hi')).toBeNull();
+  });
+
+  it('returns null when the text is empty after sanitization', async () => {
+    const tts = ttsReturning([1, 2, 3]);
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: tts.fn as any,
+      getWhisperModelId: () => null,
+      getTtsModelId: () => 'tts-1',
+    });
+    // Only non-ASCII / markup ⇒ sanitizes to empty ⇒ no synthesis attempted.
+    expect(await voice.synthesizeSpeech('✨🎉')).toBeNull();
+    expect(tts.calls).toHaveLength(0);
+  });
+
+  it('redacts payment strings before synthesis and returns PCM + sample rate', async () => {
+    const tts = ttsReturning([10, 20, 30]);
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: tts.fn as any,
+      getWhisperModelId: () => null,
+      getTtsModelId: () => 'tts-1',
+      ttsSampleRate: 22050,
+    });
+    const out = await voice.synthesizeSpeech('Pay lnbc1' + 'q'.repeat(60) + ' now');
+    expect(out).toEqual({ pcm: [10, 20, 30], sampleRate: 22050 });
+    expect(tts.calls[0].text).toContain('Lightning invoice');
+    expect(tts.calls[0].text).not.toMatch(/lnbc1q/i);
+    expect(tts.calls[0]).toMatchObject({ modelId: 'tts-1', inputType: 'text', stream: false });
+  });
+
+  it('defaults to the SUPERTONIC 44.1 kHz sample rate', async () => {
+    const tts = ttsReturning([1]);
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: tts.fn as any,
+      getWhisperModelId: () => null,
+      getTtsModelId: () => 'tts-1',
+    });
+    const out = await voice.synthesizeSpeech('Your balance is five thousand sats');
+    expect(out?.sampleRate).toBe(44100);
+  });
+});
+
+describe('createQvacVoice.openVoiceSession', () => {
+  const fakeSession = {
+    write() {},
+    end() {},
+    destroy() {},
+    async *[Symbol.asyncIterator]() {},
+  };
+
+  it('opens a VAD stream with the whisper model + default params', async () => {
+    const calls: any[] = [];
+    const transcribeStream = (p: any) => {
+      calls.push(p);
+      return Promise.resolve(fakeSession);
+    };
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: (() => {}) as any,
+      transcribeStream: transcribeStream as any,
+      getWhisperModelId: () => 'w1',
+      getTtsModelId: () => null,
+    });
+    const session = await voice.openVoiceSession();
+    expect(session).toBe(fakeSession);
+    expect(calls[0]).toMatchObject({ modelId: 'w1', emitVadEvents: true, endOfTurnSilenceMs: 700 });
+  });
+
+  it('merges param overrides over the defaults', async () => {
+    const calls: any[] = [];
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: (() => {}) as any,
+      transcribeStream: ((p: any) => { calls.push(p); return Promise.resolve(fakeSession); }) as any,
+      getWhisperModelId: () => 'w1',
+      getTtsModelId: () => null,
+    });
+    await voice.openVoiceSession({ endOfTurnSilenceMs: 1200 });
+    expect(calls[0].endOfTurnSilenceMs).toBe(1200);
+    expect(calls[0].emitVadEvents).toBe(true);
+  });
+
+  it('throws when transcribeStream was not provided', async () => {
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: (() => {}) as any,
+      getWhisperModelId: () => 'w1',
+      getTtsModelId: () => null,
+    });
+    await expect(voice.openVoiceSession()).rejects.toThrow(/transcribeStream not provided/);
+  });
+
+  it('throws when no Whisper model is loaded', async () => {
+    const voice = createQvacVoice({
+      transcribe: (() => {}) as any,
+      textToSpeech: (() => {}) as any,
+      transcribeStream: (() => Promise.resolve(fakeSession)) as any,
+      getWhisperModelId: () => null,
+      getTtsModelId: () => null,
+    });
+    await expect(voice.openVoiceSession()).rejects.toThrow(/not loaded/);
+  });
+});

package/src/qvac/voice.ts

@@ -0,0 +1,122 @@
+/**
+ * Voice runtime ops shared across hosts: one-shot transcription (Whisper) and
+ * speech synthesis (SUPERTONIC TTS). Like the provider, the SDK functions are
+ * 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
+ * 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).
+ *
+ * The streaming voice-assistant loop (transcribeStream + VAD) builds on top of
+ * these in a later pass.
+ */
+import type * as QvacSdk from '@qvac/sdk';
+import { sanitizeForSupertonic } from './text.js';
+import { TTS_SAMPLE_RATE, DEFAULT_VOICE_STREAM_PARAMS } from './config.js';
+import type { VoiceTranscriptEvent } from './assistant.js';
+
+type TranscribeFn = typeof QvacSdk.transcribe;
+type TextToSpeechFn = typeof QvacSdk.textToSpeech;
+type TranscribeStreamFn = typeof QvacSdk.transcribeStream;
+
+/** 16-bit PCM samples plus their sample rate, ready for the host to play. */
+export interface PcmAudio {
+  pcm: number[];
+  sampleRate: number;
+}
+
+/**
+ * A live VAD transcription session: feed mic audio with `write()`, iterate to
+ * receive `text`/`vad`/`endOfTurn` events, `end()` when audio stops. Pass it
+ * straight to `runVoiceAssistant`.
+ */
+export interface VoiceSession {
+  write(audioChunk: Uint8Array): void;
+  end(): void;
+  destroy(): void;
+  [Symbol.asyncIterator](): AsyncIterator<VoiceTranscriptEvent>;
+}
+
+export interface QvacVoiceOptions {
+  /** The SDK's `transcribe` (injected). */
+  transcribe: TranscribeFn;
+  /** The SDK's `textToSpeech` (injected). */
+  textToSpeech: TextToSpeechFn;
+  /** The SDK's `transcribeStream` (injected) — only needed for `openVoiceSession`. */
+  transcribeStream?: TranscribeStreamFn;
+  /** Resolve the loaded Whisper model id (null ⇒ not loaded → throws). */
+  getWhisperModelId: () => string | null;
+  /** Resolve the loaded TTS model id (null ⇒ not loaded → returns null). */
+  getTtsModelId: () => string | null;
+  /** TTS output sample rate; defaults to SUPERTONIC-2's 44.1 kHz. */
+  ttsSampleRate?: number;
+}
+
+export interface QvacVoice {
+  /** Transcribe an audio file (path or `file://` URI) to text. */
+  transcribeAudio(audioUri: string): Promise<string>;
+  /**
+   * Synthesize speech for `text`. Returns PCM + sample rate, or `null` when TTS
+   * is unavailable or the text is empty after sanitization (host falls back to
+   * the system voice). Payment strings are redacted so they're never read aloud.
+   */
+  synthesizeSpeech(text: string): Promise<PcmAudio | null>;
+  /**
+   * Open a hands-free VAD transcription session (continuous voice). Requires
+   * `transcribeStream` to have been provided. Merge in `paramsOverride` to tune
+   * the defaults ({@link DEFAULT_VOICE_STREAM_PARAMS}). Feed the returned session
+   * to `runVoiceAssistant`.
+   */
+  openVoiceSession(paramsOverride?: Record<string, unknown>): Promise<VoiceSession>;
+}
+
+export function createQvacVoice(options: QvacVoiceOptions): QvacVoice {
+  const sampleRate = options.ttsSampleRate ?? TTS_SAMPLE_RATE;
+
+  return {
+    async transcribeAudio(audioUri: string): Promise<string> {
+      const modelId = options.getWhisperModelId();
+      if (!modelId) throw new Error('Whisper model not loaded');
+      // The SDK's native file reader wants a plain filesystem path, not a
+      // `file://` URI — the URI raises AUDIO_FILE_NOT_FOUND even when present.
+      const audioChunk = audioUri.replace('file://', '');
+      return await options.transcribe({ modelId, audioChunk } as Parameters<TranscribeFn>[0]);
+    },
+
+    async synthesizeSpeech(text: string): Promise<PcmAudio | null> {
+      const modelId = options.getTtsModelId();
+      if (!modelId) return null;
+
+      const trimmed = sanitizeForSupertonic(text);
+      if (!trimmed) return null;
+      // Belt-and-suspenders: SUPERTONIC chokes on U+0060; sanitize already
+      // strips it, so refuse if any slipped through rather than crash the voice.
+      if (Array.from(trimmed).some((ch) => ch.charCodeAt(0) === 0x60)) return null;
+
+      const result = options.textToSpeech({
+        modelId,
+        text: trimmed,
+        inputType: 'text',
+        stream: false,
+      } as Parameters<TextToSpeechFn>[0]);
+      const pcm = await result.buffer;
+      return { pcm, sampleRate };
+    },
+
+    async openVoiceSession(paramsOverride: Record<string, unknown> = {}): Promise<VoiceSession> {
+      if (!options.transcribeStream) {
+        throw new Error('transcribeStream not provided — pass it in QvacVoiceOptions for voice sessions');
+      }
+      const modelId = options.getWhisperModelId();
+      if (!modelId) throw new Error('Whisper model not loaded');
+      const session = await options.transcribeStream({
+        modelId,
+        ...DEFAULT_VOICE_STREAM_PARAMS,
+        ...paramsOverride,
+      } as Parameters<TranscribeStreamFn>[0]);
+      return session as unknown as VoiceSession;
+    },
+  };
+}

package/src/recipe/buy-asset-channel.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ToolRegistry } from '../tools/registry.js';
+import { InProcessToolSource } from '../tools/in-process.js';
+import type { LLMProvider } from '../providers/types.js';
+import { runRecipe, RecipeRegistry } from './runner.js';
+import { buyAssetChannelRecipe, extractBuyAsset } from './buy-asset-channel.js';
+import { swapRecipe } from './swap.js';
+import { assetSendRecipe } from './asset-send.js';
+
+const approve: LLMProvider = { name: 'x', runTurn: async () => ({ text: '', rawContent: '', toolCalls: [] }) };
+
+/** Stub the two asset-channel tools the recipe drives. */
+function stubTools(spy?: { create?: (a: any) => void }) {
+  return new ToolRegistry([
+    new InProcessToolSource('ks', [
+      {
+        name: 'kaleidoswap_lsp_quote_asset_channel',
+        description: '',
+        parameters: { type: 'object', properties: {} },
+        handler: async (a) => ({
+          rfq_id: 'rfq1',
+          asset_amount: a.asset_amount,
+          btc_amount_sat: 13807,
+          channel_fee_sat: 16139,
+          total_sat: 29946,
+          expires_at: 1234567890,
+        }),
+      },
+      {
+        name: 'kaleidoswap_lsp_create_asset_channel',
+        description: '',
+        parameters: { type: 'object', properties: {} },
+        requiresConfirmation: true,
+        handler: async (a) => {
+          spy?.create?.(a);
+          return { order_id: 'ord1', total_sat: 29946, payment: { onchain_address: 'bcrt1qexample' } };
+        },
+      },
+    ]),
+  ]);
+}
+
+describe('extractBuyAsset (deterministic Tier-0)', () => {
+  it('parses "buy 100 usdt"', () => {
+    expect(extractBuyAsset('buy 100 usdt')).toEqual({ asset: 'USDT', asset_amount: 100 });
+  });
+  it('parses "get me 50 xaut"', () => {
+    expect(extractBuyAsset('get me 50 xaut')).toEqual({ asset: 'XAUT', asset_amount: 50 });
+  });
+  it('parses "i want 200 usdt" and "purchase 10 xaut"', () => {
+    expect(extractBuyAsset('i want 200 usdt')).toEqual({ asset: 'USDT', asset_amount: 200 });
+    expect(extractBuyAsset('purchase 10 xaut')).toEqual({ asset: 'XAUT', asset_amount: 10 });
+  });
+  it('handles comma grouping in the amount', () => {
+    expect(extractBuyAsset('buy 1,000 usdt')).toEqual({ asset: 'USDT', asset_amount: 1000 });
+  });
+  it('null for a swap (a named source asset ⇒ swap owns it)', () => {
+    expect(extractBuyAsset('buy 0.001 btc with usdt')).toBeNull();
+    expect(extractBuyAsset('swap 10 usdt for btc')).toBeNull();
+    expect(extractBuyAsset('buy 100 usdt with my bitcoin')).toBeNull();
+  });
+  it('null for a send (asset-send owns it)', () => {
+    expect(extractBuyAsset('send 10 usdt to bob')).toBeNull();
+  });
+  it('null for BTC (BTC is not bought via an asset channel)', () => {
+    expect(extractBuyAsset('buy 100000 sats')).toBeNull();
+    expect(extractBuyAsset('get 0.01 btc')).toBeNull();
+  });
+});
+
+describe('runRecipe — buy asset channel', () => {
+  it('quote → confirm → create order, deterministic (0 inferences)', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const onConfirm = vi.fn(async () => ({ approved: true }));
+    const res = await runRecipe(buyAssetChannelRecipe, 'buy 100 usdt', { provider: approve, tools, onConfirm });
+
+    expect(res.status).toBe('done');
+    expect(res.inferences).toBe(0);
+    expect(onConfirm).toHaveBeenCalledOnce();
+    expect(res.results.quote).toMatchObject({ rfq_id: 'rfq1' });
+    expect(created[0]).toMatchObject({ asset: 'USDT', asset_amount: 100, rfq_id: 'rfq1' });
+    // The quote's cost rides along for the confirm card.
+    expect(created[0]).toMatchObject({ total_sat: 29946, btc_amount_sat: 13807, channel_fee_sat: 16139 });
+    expect(res.text).toContain('100 USDT');
+    expect(res.text).toContain('29,946');
+  });
+
+  it('denied confirmation → cancelled, no order placed', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const res = await runRecipe(buyAssetChannelRecipe, 'buy 100 usdt', {
+      provider: approve,
+      tools,
+      onConfirm: async () => ({ approved: false }),
+    });
+    expect(res.status).toBe('cancelled');
+    expect(created).toHaveLength(0);
+  });
+
+  it('fails closed when no confirm handler is wired (spend never runs)', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const res = await runRecipe(buyAssetChannelRecipe, 'buy 100 usdt', { provider: approve, tools });
+    expect(res.status).toBe('cancelled');
+    expect(created).toHaveLength(0);
+  });
+
+  it('falls back to ONE LLM extraction when the regex misses', async () => {
+    const created: any[] = [];
+    const tools = stubTools({ create: (a) => created.push(a) });
+    const llmOnly = { ...buyAssetChannelRecipe, extract: undefined };
+    const provider: LLMProvider = {
+      name: 'mock',
+      runTurn: vi.fn(async () => ({
+        text: '',
+        rawContent: '',
+        toolCalls: [{ id: '1', name: 'extract_request', arguments: { asset: 'USDT', asset_amount: 100 } }],
+      })),
+    };
+    const res = await runRecipe(llmOnly, 'could you set me up with a hundred tether', {
+      provider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+    });
+    expect(res.inferences).toBe(1);
+    expect(provider.runTurn).toHaveBeenCalledOnce();
+    expect(created[0]).toMatchObject({ asset: 'USDT', asset_amount: 100, rfq_id: 'rfq1' });
+  });
+});
+
+describe('recipe selection / precedence', () => {
+  it('selects buy-asset-channel before swap for "buy 100 usdt"', () => {
+    const reg = new RecipeRegistry([buyAssetChannelRecipe, swapRecipe]);
+    expect(reg.select('buy 100 usdt')?.name).toBe('buy-asset-channel');
+    expect(reg.select('get me 50 xaut')?.name).toBe('buy-asset-channel');
+  });
+  it('does not hijack a swap or an asset send', () => {
+    const reg = new RecipeRegistry([buyAssetChannelRecipe, swapRecipe, assetSendRecipe]);
+    expect(reg.select('swap 10 usdt for btc')?.name).not.toBe('buy-asset-channel');
+    expect(reg.select('send 10 usdt to bob')?.name).not.toBe('buy-asset-channel');
+  });
+  it('confident only with both asset and a positive amount', () => {
+    expect(buyAssetChannelRecipe.confident!({ asset: 'USDT', asset_amount: 100 })).toBe(true);
+    expect(buyAssetChannelRecipe.confident!({ asset: 'USDT' })).toBe(false);
+    expect(buyAssetChannelRecipe.confident!({ asset: 'USDT', asset_amount: 0 })).toBe(false);
+  });
+});

package/src/recipe/buy-asset-channel.ts

@@ -0,0 +1,118 @@
+/**
+ * Built-in "buy an asset channel" recipe — the onboarding buy.
+ *
+ * The user has on-chain BTC but no Lightning channel yet, and wants to HOLD an
+ * RGB asset (USDT, XAUT). They can't swap (no channel to swap inside), so they
+ * buy a NEW channel from the maker LSP pre-loaded with the asset. One quote,
+ * one spend:
+ *
+ *   "buy 100 usdt"  /  "get me 50 xaut"  /  "i want 200 usdt"
+ *     ↓ 1 model inference (slot extraction; 0 when the regex hits)
+ *   kaleidoswap_lsp_quote_asset_channel    ← maker prices the asset + channel
+ *   kaleidoswap_lsp_create_asset_channel 🔒 ← (final) order it; pay to open
+ *
+ * Distinct from `swapRecipe`: a swap names a source asset ("swap 10 usdt FOR
+ * btc", "buy btc WITH usdt") and needs an existing channel. This is the
+ * no-source, no-channel onboarding path — "buy <amount> <asset>" with nothing
+ * to spend it from — so it must be SELECTED BEFORE swap for that phrasing.
+ *
+ * Opt-in: register via `Funnel.recipes` (like `kaleidoswapAtomicRecipe`). The
+ * host binds `kaleidoswap_lsp_*` to its transport (maker REST / MCP / WDK).
+ */
+
+import type { Recipe } from './types.js';
+
+/** RGB assets the maker sells as an asset channel. BTC is never "bought" this way. */
+const RGB_ASSET = /\b(usdt|tether|xaut|gold)\b/i;
+/** A named funding source ⇒ this is a swap, not an onboarding buy. */
+const HAS_SOURCE = /\b(?:with|using|from)\b|\bfor\s+(?:btc|bitcoin|sats?|usdt|xaut|tether|gold)\b/i;
+/** Verbs other intents own (swap / sell / send) — never an onboarding buy. */
+const NOT_BUY = /\b(swap|exchange|convert|trade|sell|send)\b/i;
+/** Acquire verbs that DO mean an onboarding buy. */
+const BUY_VERB = /\b(buy|get|acquire|want|purchase|onboard|need)\b/i;
+
+function normAsset(a?: string): string | undefined {
+  if (!a) return undefined;
+  const x = a.toLowerCase();
+  if (/usdt|tether/.test(x)) return 'USDT';
+  if (/xaut|gold/.test(x)) return 'XAUT';
+  return undefined;
+}
+
+const num = (s?: string): number | undefined => {
+  if (!s) return undefined;
+  const n = Number(s.replace(/,/g, ''));
+  return Number.isFinite(n) ? n : undefined;
+};
+
+/** Thousands separators, locale-independent (deterministic for tests). */
+const commas = (n: number): string => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+
+/** "buy 100 usdt" / "get me 50 xaut" / "i want 200 usdt" / "purchase 10 xaut". */
+export function extractBuyAsset(text: string): Record<string, unknown> | null {
+  const t = text.trim();
+  if (NOT_BUY.test(t) || HAS_SOURCE.test(t)) return null;
+  if (!RGB_ASSET.test(t)) return null;
+  // buy/get/want/acquire/purchase [me] <amount> <asset>
+  const m = t.match(/\b(?:buy|get|acquire|want|purchase|onboard|need)\b(?:\s+me)?\s+([\d.,]+)\s*([a-z]+)/i);
+  if (!m) return null;
+  const asset = normAsset(m[2]);
+  const amount = num(m[1]);
+  if (!asset || amount === undefined) return null;
+  return { asset, asset_amount: amount };
+}
+
+export const buyAssetChannelRecipe: Recipe = {
+  name: 'buy-asset-channel',
+  description:
+    'Onboarding buy: purchase a new Lightning channel pre-loaded with an RGB asset (USDT, XAUT) from the maker LSP — for a user with on-chain BTC but no channel yet. Quote, then order (with confirmation).',
+  // "buy/get/want N <rgb-asset>" with NO named source asset and NO swap/send verb.
+  match: (t) => !NOT_BUY.test(t) && !HAS_SOURCE.test(t) && RGB_ASSET.test(t) && BUY_VERB.test(t),
+  triggers: ['buy', 'get', 'purchase', 'acquire'],
+  slots: [
+    { name: 'asset', type: 'string', description: 'RGB asset to acquire (USDT or XAUT)', required: true },
+    { name: 'asset_amount', type: 'number', description: 'Amount of the asset to load into the channel (display units, e.g. 100)', required: true },
+  ],
+  extract: extractBuyAsset,
+  confident: (s) => !!s.asset && s.asset_amount !== undefined && Number(s.asset_amount) > 0,
+  steps: [
+    // 1. Maker prices the asset + the channel.
+    //    Returns { rfq_id, btc_amount_sat, channel_fee_sat, total_sat, expires_at }.
+    {
+      tool: 'kaleidoswap_lsp_quote_asset_channel',
+      as: 'quote',
+      args: (ctx) => ({ asset: ctx.slots.asset, asset_amount: ctx.slots.asset_amount }),
+    },
+  ],
+  // 2. Order the channel with the fresh rfq_id. Spend → confirmation-gated.
+  //    The quote's cost fields ride along so the host's confirm card can show
+  //    the price before approval; the create tool treats them as display-only.
+  final: {
+    tool: 'kaleidoswap_lsp_create_asset_channel',
+    args: (ctx) => {
+      const q = (ctx.results.quote ?? {}) as {
+        rfq_id?: string;
+        total_sat?: number;
+        btc_amount_sat?: number;
+        channel_fee_sat?: number;
+        expires_at?: number;
+      };
+      return {
+        asset: ctx.slots.asset,
+        asset_amount: ctx.slots.asset_amount,
+        rfq_id: q.rfq_id,
+        total_sat: q.total_sat,
+        btc_amount_sat: q.btc_amount_sat,
+        channel_fee_sat: q.channel_fee_sat,
+        expires_at: q.expires_at,
+      };
+    },
+  },
+  summary: (ctx, finalResult) => {
+    const q = ctx.results.quote as { total_sat?: number } | undefined;
+    const o = finalResult as { order_id?: string } | undefined;
+    const cost = typeof q?.total_sat === 'number' ? ` for ${commas(q.total_sat)} sats` : '';
+    const id = o?.order_id ? ` (order ${o.order_id})` : '';
+    return `Ordered a Lightning channel with ${ctx.slots.asset_amount} ${ctx.slots.asset}${cost}${id}. Pay the returned invoice/address to open it.`;
+  },
+};