@kaleidorg/mind 0.4.0 → 0.5.1

package/src/lsps1/contract.ts

@@ -50,31 +50,49 @@ export const LSPS1_TOOLS: Lsps1ToolDef[] = [
     "Get the LSP's Lightning network info: pubkey, host, port, connect URI. Useful to display the counterparty or pre-connect a peer. No args."),
 
   t('lsp_estimate_fees',
-    "Estimate the fee for a channel order BEFORE committing. Returns the total cost in sats plus any LSP routing fee. Re-estimate rather than reusing a stale value.",
+    "Estimate the channel-order fee BEFORE committing. Returns setup_fee, capacity_fee, duration_fee, total_fee (all in sats). Re-estimate rather than reusing a stale value.",
     {
-      lsp_balance_sat:    { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
-      client_balance_sat: { type: 'number', description: "Sats the user pre-funds into the channel (push amount). Often 0." },
-      channel_expiry_blocks: { type: 'number', description: 'Optional minimum lease in blocks. Defaults to the LSP minimum.' },
+      lsp_balance_sat:       { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
+      client_balance_sat:    { type: 'number', description: "Sats the user pre-funds into the channel (push amount). Default 0." },
+      channel_expiry_blocks: { type: 'number', description: 'Lease duration in blocks. Default 4320 (~30 days). Maker maximum is typically 20160 (~140 days).' },
+      // RGB asset channels (optional):
+      asset_id:              { type: 'string', description: 'For RGB asset channels — the asset to provision liquidity for.' },
+      lsp_asset_amount:      { type: 'number', description: 'Asset units the LSP commits (RGB channels only).' },
+      client_asset_amount:   { type: 'number', description: 'Asset units the user pre-funds (RGB channels only). Requires rfq_id.' },
+      rfq_id:                { type: 'string', description: 'Quote id from kaleidoswap_get_quote — required when client_asset_amount > 0.' },
+      token:                 { type: 'string', description: 'Optional discount/affiliate token.' },
     },
-    ['lsp_balance_sat']),
+    ['lsp_balance_sat', 'client_balance_sat', 'channel_expiry_blocks']),
 
   t('lsp_create_order',
-    "Create a channel order. SPEND: confirmation-gated. Returns an order id + a Lightning invoice the user pays to lock the order. The channel opens only after payment.",
+    "Create a channel order. SPEND: confirmation-gated. Returns order_id + access_token + a payment.bolt11.invoice the user pays to lock the order. The channel opens only after payment.",
     {
-      lsp_balance_sat:    { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
-      client_balance_sat: { type: 'number', description: 'Sats the user pre-funds. Often 0.' },
-      channel_expiry_blocks: { type: 'number', description: 'Minimum lease in blocks. Defaults to LSP minimum from lsp_get_info.' },
-      refund_onchain_address: { type: 'string', description: 'Optional on-chain refund address if the LSP cannot open the channel.' },
+      client_pubkey:                  { type: 'string', description: "User's Lightning node pubkey — the LSP opens the channel TO this node. Get it from rln_get_node_info." },
+      lsp_balance_sat:                { type: 'number', description: "Sats the LSP commits on their side (inbound capacity for the user)." },
+      client_balance_sat:             { type: 'number', description: "Sats the user pre-funds. Default 0." },
+      required_channel_confirmations: { type: 'number', description: 'Number of confs the user wants before considering the channel usable. Default 1.' },
+      funding_confirms_within_blocks: { type: 'number', description: 'Max blocks within which funding must confirm. Default 6.' },
+      channel_expiry_blocks:          { type: 'number', description: 'Lease duration in blocks. Default 4320 (~30 days).' },
+      announce_channel:               { type: 'boolean', description: 'Public (true) or unannounced (false). Default true.' },
+      refund_onchain_address:         { type: 'string', description: 'Optional on-chain refund address if the LSP cannot open the channel.' },
+      // RGB asset channels (optional):
+      asset_id:                       { type: 'string', description: 'For RGB asset channels.' },
+      lsp_asset_amount:               { type: 'number', description: 'Asset units the LSP commits.' },
+      client_asset_amount:            { type: 'number', description: 'Asset units the user pre-funds.' },
+      rfq_id:                         { type: 'string', description: 'Required when client_asset_amount > 0.' },
+      token:                          { type: 'string', description: 'Optional discount/affiliate token.' },
+      email:                          { type: 'string', description: 'Optional contact for order updates.' },
     },
-    ['lsp_balance_sat'],
+    ['client_pubkey', 'lsp_balance_sat'],
     /* spend */ true),
 
   t('lsp_get_order',
-    'Check the status of an LSPS1 order — pending / paid / opening / completed / failed. Poll after creating an order until the channel opens.',
+    'Check the status of an LSPS1 order. order_state progresses CREATED → CHANNEL_OPENING → COMPLETED (or FAILED). ALWAYS pass BOTH the order_id and the access_token from lsp_create_order (the access_token is required for order status).',
     {
-      order_id: { type: 'string', description: 'The order id from lsp_create_order.' },
+      order_id:     { type: 'string', description: 'The order id from lsp_create_order.' },
+      access_token: { type: 'string', description: 'The per-order access token returned by lsp_create_order. Required for non-admin reads.' },
     },
-    ['order_id']),
+    ['order_id', 'access_token']),
 ];
 
 /** All LSPS1 tool names that move funds (confirmation-gated). */

package/src/qvac/parse.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { finalToTurn } from './parse.js';
+import { finalToTurn, extractTextToolCalls } from './parse.js';
 
 describe('finalToTurn', () => {
   it('uses contentText for visible text and strips reasoning', () => {
@@ -49,4 +49,73 @@ describe('finalToTurn', () => {
     const out = finalToTurn({});
     expect(out).toEqual({ text: '', rawContent: '', toolCalls: [], truncated: false, stopReason: undefined });
   });
+
+  // The QVAC SDK / small models sometimes emit tool calls as plain text instead
+  // of structured frames; finalToTurn must recover them so they still execute.
+  describe('inline tool-call recovery (SDK gave no structured toolCalls)', () => {
+    it('recovers a <tool_call> block and hides the tags from the answer', () => {
+      const out = finalToTurn({
+        contentText:
+          '<tool_call> {"name": "rln_create_rgb_invoice", "arguments": {}} </tool_call>',
+      });
+      expect(out.toolCalls).toEqual([{ name: 'rln_create_rgb_invoice', arguments: {} }]);
+      expect(out.text).toBe('');
+    });
+
+    it('keeps the trailing sentence after the tag out of the answer but runs the call', () => {
+      const out = finalToTurn({
+        contentText:
+          '<tool_call> {"name": "rln_create_rgb_invoice", "arguments": {}} </tool_call> Please specify the asset ID.',
+      });
+      expect(out.toolCalls).toEqual([{ name: 'rln_create_rgb_invoice', arguments: {} }]);
+      expect(out.text).toBe('Please specify the asset ID.');
+    });
+
+    it('recovers nested arguments', () => {
+      const out = finalToTurn({
+        contentText:
+          '<tool_call> {"name": "lsp_get_order", "arguments": {"order_id": "latest", "access_token": "latest"}} </tool_call>',
+      });
+      expect(out.toolCalls).toEqual([
+        { name: 'lsp_get_order', arguments: { order_id: 'latest', access_token: 'latest' } },
+      ]);
+    });
+
+    it('recovers a bare leading tool-call object', () => {
+      const out = finalToTurn({ contentText: '{"name": "get_balances", "arguments": {}}' });
+      expect(out.toolCalls).toEqual([{ name: 'get_balances', arguments: {} }]);
+    });
+
+    it('does NOT recover when the SDK already returned structured calls', () => {
+      const out = finalToTurn({
+        contentText: '<tool_call> {"name": "ghost", "arguments": {}} </tool_call>',
+        toolCalls: [{ name: 'real_tool', arguments: { a: 1 } }],
+      });
+      expect(out.toolCalls).toEqual([{ id: undefined, name: 'real_tool', arguments: { a: 1 } }]);
+    });
+
+    it('ignores JSON the model is merely talking about (not a call)', () => {
+      const out = finalToTurn({
+        contentText: 'A tool call looks like {"name": "x", "arguments": {}} in JSON.',
+      });
+      expect(out.toolCalls).toEqual([]);
+      expect(out.text).toContain('A tool call looks like');
+    });
+  });
+
+  describe('extractTextToolCalls', () => {
+    it('extracts multiple tagged calls', () => {
+      const calls = extractTextToolCalls(
+        '<tool_call>{"name":"a","arguments":{}}</tool_call> and <tool_call>{"name":"b","arguments":{"x":1}}</tool_call>',
+      );
+      expect(calls).toEqual([
+        { name: 'a', arguments: {} },
+        { name: 'b', arguments: { x: 1 } },
+      ]);
+    });
+
+    it('returns [] for plain prose', () => {
+      expect(extractTextToolCalls('just a normal answer')).toEqual([]);
+    });
+  });
 });

package/src/qvac/parse.ts

@@ -35,22 +35,88 @@ export interface ParsedTurn {
   stopReason?: string;
 }
 
+/** Parse the first balanced `{…}` from a string as a `{name, arguments}` call. */
+function parseCallObject(
+  s: string,
+): { name: string; arguments: Record<string, unknown> } | null {
+  const start = s.indexOf('{');
+  if (start < 0) return null;
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === '{') depth++;
+    else if (ch === '}' && --depth === 0) {
+      try {
+        const obj = JSON.parse(s.slice(start, i + 1)) as {
+          name?: unknown;
+          arguments?: unknown;
+        };
+        if (obj && typeof obj.name === 'string') {
+          const args =
+            obj.arguments && typeof obj.arguments === 'object'
+              ? (obj.arguments as Record<string, unknown>)
+              : {};
+          return { name: obj.name, arguments: args };
+        }
+      } catch {
+        /* malformed JSON — give up on this fragment */
+      }
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Recover tool calls a model emitted as PLAIN TEXT instead of structured frames
+ * — `<tool_call>{"name":…,"arguments":…}</tool_call>` (Qwen/Hermes) or a bare
+ * leading `{"name":…,"arguments":…}`. Small local models (and SDK builds that
+ * don't apply the tool grammar) do this; without recovery the call leaks into
+ * the visible answer and never runs.
+ */
+export function extractTextToolCalls(
+  text: string,
+): Array<{ name: string; arguments: Record<string, unknown> }> {
+  const calls: Array<{ name: string; arguments: Record<string, unknown> }> = [];
+  for (const m of text.matchAll(/<tool_call\b[^>]*>([\s\S]*?)<\/tool_call>/gi)) {
+    const c = parseCallObject(m[1] ?? '');
+    if (c) calls.push(c);
+  }
+  if (calls.length) return calls;
+  // No tags — accept a bare tool-call object only at the very start of the
+  // text (so we don't misread JSON the model is merely talking about).
+  if (/^\s*\{?\s*"name"\s*:/i.test(text)) {
+    const c = parseCallObject(text);
+    if (c) calls.push(c);
+  }
+  return calls;
+}
+
 /**
  * Map a completion `final` (plus the streamed fallback text) into a ParsedTurn.
  * `rawContent` prefers the SDK's framed `raw.fullText` so the Engine can anchor
  * the next turn; falls back to the visible text when a provider has no raw form.
+ *
+ * When the SDK reports no structured tool calls, we re-scan the raw text for
+ * tool calls the model emitted inline (see `extractTextToolCalls`) so they still
+ * execute instead of leaking into the chat.
  */
 export function finalToTurn(final: QvacFinalLike, streamed = ''): ParsedTurn {
   const rawText = final.contentText || streamed;
   const text = cleanAssistantVisibleText(rawText);
+  let toolCalls = (final.toolCalls ?? []).map((c) => ({
+    id: c.id,
+    name: c.name,
+    arguments: c.arguments ?? {},
+  }));
+  if (toolCalls.length === 0) {
+    const recovered = extractTextToolCalls(final.raw?.fullText ?? rawText);
+    if (recovered.length) toolCalls = recovered.map((c) => ({ id: undefined, ...c }));
+  }
   return {
     text,
     rawContent: final.raw?.fullText ?? rawText,
-    toolCalls: (final.toolCalls ?? []).map((c) => ({
-      id: c.id,
-      name: c.name,
-      arguments: c.arguments ?? {},
-    })),
+    toolCalls,
     truncated: final.stopReason === 'length',
     stopReason: final.stopReason,
   };

package/src/qvac/text.ts

@@ -15,6 +15,10 @@ export function cleanAssistantVisibleText(text: string): string {
     // Qwen-style reasoning sometimes arrives in contentText. Never show/speak it.
     .replace(/<think\b[\s\S]*?<\/think>/gi, ' ')
     .replace(/<think\b[\s\S]*$/gi, ' ')
+    // Tool calls some models emit as text (<tool_call>{…}</tool_call>) are
+    // extracted + executed by the Engine (see parse.ts); never show the tags.
+    .replace(/<tool_call\b[^>]*>[\s\S]*?<\/tool_call>/gi, ' ')
+    .replace(/<tool_call\b[^>]*>[\s\S]*$/gi, ' ')
     .replace(/\s+/g, ' ')
     .trim();
 

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.`;
+  },
+};