@kaleidorg/mind 0.6.4 → 0.7.0

package/src/testing/scripted-provider.ts

@@ -0,0 +1,37 @@
+/**
+ * A scripted LLMProvider — replays planned turns instead of running a model.
+ *
+ * Lets hosts wire the full Engine / Funnel (skills, recipes, confirm gate) in
+ * unit tests, CI and demos without loading a QVAC model. Deterministic tiers
+ * (fast-path, recipes with regex extraction) never call it at all.
+ */
+
+import type { ToolCall } from '../types.js';
+import type { LLMProvider } from '../providers/types.js';
+
+export interface ScriptedTurn {
+  /** Assistant text for this turn. */
+  text?: string;
+  /** Tool to call — ignored when the tool is not in the turn's scoped tool list. */
+  tool?: string;
+  args?: Record<string, unknown>;
+}
+
+export function scriptedProvider(turns: ScriptedTurn[] = [], fallback = 'I need more information.'): LLMProvider {
+  let index = 0;
+  return {
+    name: 'scripted',
+    async runTurn(input) {
+      const planned = turns[index++] ?? { text: fallback };
+      const call: ToolCall | undefined = planned.tool && input.tools.some((t) => t.name === planned.tool)
+        ? { id: `scripted-${index}`, name: planned.tool, arguments: planned.args ?? {} }
+        : undefined;
+      return {
+        text: planned.text ?? '',
+        rawContent: planned.text ?? '',
+        toolCalls: call ? [call] : [],
+        inference: { durationMs: 0, status: 'completed' },
+      };
+    },
+  };
+}

package/src/wallet/confirm.test.ts

@@ -48,6 +48,22 @@ describe('confirmReadback', () => {
     expect(line).toBe('Pay Lightning invoice lnbc1p…abcd over Spark. Confirm?');
   });
 
+  it('rln_send_asset: kaleido-mcp argument names', () => {
+    expect(confirmReadback({ name: 'rln_send_asset', arguments: { asset_id: 'rgb:abcdefgh-1234567890-xyz', amount: 5, recipient_id: 'utxob:ab12cd34ef56gh78ij90' } }))
+      .toBe('Send 5 rgb:ab…-xyz to utxob:…ij90 over RLN. Confirm?');
+  });
+
+  it('rln_send_btc / channel / atomic taker readbacks', () => {
+    expect(confirmReadback({ name: 'rln_send_btc', arguments: { address: 'tb1qexampleaddress0000000000xyz', amount_sat: 25000 } }))
+      .toBe('Send 25,000 sats on-chain to tb1qex…0xyz over RLN. Confirm?');
+    expect(confirmReadback({ name: 'rln_open_channel', arguments: { peer_pubkey_and_addr: '03abcdef0123456789abcdef0123456789@1.2.3.4:9735', capacity_sat: 100000 } }))
+      .toBe('Open a 100,000 sats channel to 03abcd…6789. Confirm?');
+    expect(confirmReadback({ name: 'rln_close_channel', arguments: { channel_id: 'chan0123456789abcdef0123', peer_pubkey: 'x', force: true } }))
+      .toBe('Force-close channel chan01…0123. Confirm?');
+    expect(confirmReadback({ name: 'rln_atomic_taker', arguments: { swapstring: '30/rgb:asset/10/btc/3600/abcdef0123456789' } }))
+      .toBe('Accept atomic swap 30/rgb…6789 on your node. Confirm?');
+  });
+
   it('execute_swap: from → to with amount', () => {
     expect(confirmReadback({ name: 'execute_swap', arguments: { from_asset: 'BTC', to_asset: 'USDT', amount: 0.01 } }))
       .toBe('Swap 0.01 BTC for USDT. Confirm?');

package/src/wallet/confirm.ts

@@ -62,10 +62,30 @@ export function confirmReadback(call: { name: string; arguments: Record<string,
       return ask(`Send ${sats(a.amount_sats)} to ${to()}${over(name, a)}`);
     case 'rln_send_asset':
     case 'liquid_send':
-      return ask(`Send ${asset(a.amount, a.asset)} to ${to()}${over(name, a)}`);
+      // kaleido-mcp names these asset_id / recipient_id.
+      return ask(`Send ${asset(a.amount, a.asset ?? shortRef(String(a.asset_id ?? '')))} to ${to(a.to != null ? 'to' : 'recipient_id')}${over(name, a)}`);
     case 'rln_pay_invoice':
     case 'spark_pay_invoice':
       return ask(`Pay Lightning invoice ${shortRef(String(a.invoice ?? ''))}${over(name, a)}`);
+    case 'rln_issue_asset': {
+      const label = a.name != null && a.ticker != null && String(a.name) !== String(a.ticker) ? ` (${String(a.name)})` : '';
+      return a.schema === 'UDA'
+        ? ask(`Issue unique asset ${String(a.ticker ?? a.name)}${label} on RGB`)
+        : ask(`Issue ${asset(a.amount, a.ticker ?? a.name)}${label}, a new RGB asset`);
+    }
+    case 'rln_create_utxos':
+      return ask(`Create ${fmtNum(Number(a.num ?? 5))} RGB UTXOs on-chain${over(name, a)}`);
+    case 'rln_send_btc':
+      return ask(`Send ${sats(a.amount_sat)} on-chain to ${to('address')}${over(name, a)}`);
+    case 'rln_open_channel': {
+      const peer = shortRef(String(a.peer_pubkey_and_addr ?? '').split('@')[0] ?? '');
+      const withAsset = a.asset_id != null && a.asset_amount != null ? ` with ${fmtNum(Number(a.asset_amount))} of ${shortRef(String(a.asset_id))}` : '';
+      return ask(`Open a ${sats(a.capacity_sat)} channel to ${peer}${withAsset}`);
+    }
+    case 'rln_close_channel':
+      return ask(`${a.force ? 'Force-close' : 'Close'} channel ${shortRef(String(a.channel_id ?? ''))}`);
+    case 'rln_atomic_taker':
+      return ask(`Accept atomic swap ${shortRef(String(a.swapstring ?? ''))} on your node`);
     case 'execute_swap':
       return ask(`Swap ${fmtNum(Number(a.amount))} ${String(a.from_asset)} for ${String(a.to_asset)}`);
     default:

package/src/wallet/contract.test.ts

@@ -1,6 +1,8 @@
 /** Wallet contract tests — integrity of the single source of truth. */
 
 import { describe, it, expect, vi } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { parseSkill } from '../skills/registry.js';
 import {
   WALLET_TOOLS,
   SPEND_TOOLS,
@@ -40,9 +42,13 @@ describe('WALLET_TOOLS contract', () => {
     expect(isSpendTool('execute_swap')).toBe(true);
     expect(isSpendTool('spark_send')).toBe(true);
     expect(isSpendTool('spark_pay_invoice')).toBe(true);
+    expect(isSpendTool('rln_issue_asset')).toBe(true);
+    expect(isSpendTool('rln_create_utxos')).toBe(true);
     // reads are not
     expect(isSpendTool('get_balances')).toBe(false);
     expect(isSpendTool('get_price')).toBe(false);
+    expect(isSpendTool('rln_list_assets')).toBe(false);
+    expect(isSpendTool('rln_list_transfers')).toBe(false);
     expect([...SPEND_TOOLS].length).toBeGreaterThanOrEqual(5);
   });
 
@@ -97,3 +103,35 @@ describe('bindWalletTools', () => {
     expect(src.listTools().map((t) => t.name)).toEqual(['spark_get_balance']);
   });
 });
+
+describe('RLN tools vs kaleido-mcp and the rgb-lightning-node skill', () => {
+  // The rln_* tools kaleido-mcp registers (rln_mpp_pay belongs to paid-data).
+  const MCP_RLN = [
+    'rln_get_node_info', 'rln_get_balances', 'rln_get_asset_balance', 'rln_list_assets',
+    'rln_get_address', 'rln_create_rgb_invoice', 'rln_create_ln_invoice', 'rln_pay_invoice',
+    'rln_send_btc', 'rln_send_asset', 'rln_list_channels', 'rln_connect_peer', 'rln_open_channel',
+    'rln_close_channel', 'rln_get_channel_id', 'rln_list_payments', 'rln_refresh_transfers',
+    'rln_atomic_taker', 'rln_list_swaps', 'rln_get_swap',
+  ];
+
+  it('covers every rln_* tool kaleido-mcp exposes', () => {
+    const missing = MCP_RLN.filter((n) => !getWalletTool(n));
+    expect(missing).toEqual([]);
+  });
+
+  it('gates every fund-moving or committing RLN tool', () => {
+    for (const n of ['rln_send_btc', 'rln_open_channel', 'rln_close_channel', 'rln_atomic_taker']) {
+      expect(isSpendTool(n)).toBe(true);
+    }
+    for (const n of ['rln_get_asset_balance', 'rln_refresh_transfers', 'rln_list_swaps', 'rln_get_swap']) {
+      expect(isSpendTool(n)).toBe(false);
+    }
+  });
+
+  it('the skill only declares tools that exist in the contract', () => {
+    const md = readFileSync(new URL('../../skills/rgb-lightning-node/SKILL.md', import.meta.url), 'utf8');
+    const skill = parseSkill(md);
+    const unknown = (skill.tools ?? []).filter((n) => !getWalletTool(n));
+    expect(unknown).toEqual([]);
+  });
+});

package/src/wallet/contract.ts

@@ -91,6 +91,42 @@ export const WALLET_TOOLS: WalletToolDef[] = [
   t('rln', 'rln_create_rgb_invoice', 'Create an RGB asset invoice to receive an asset (e.g. USDT).', { asset, amount: { type: 'number', description: 'Asset amount' } }, ['asset', 'amount']),
   t('rln', 'rln_pay_invoice', 'Pay a Lightning invoice from the RLN node.', { invoice: { type: 'string' } }, ['invoice'], true),
   t('rln', 'rln_send_asset', 'Send an RGB asset (e.g. USDT) to a recipient.', { asset, amount: { type: 'number' }, to: { type: 'string' } }, ['asset', 'amount', 'to'], true),
+  t('rln', 'rln_list_assets', 'List RGB assets held by the RLN node (asset_id, ticker, name, precision, balances).'),
+  t('rln', 'rln_get_asset_balance', 'Get the balance of one RGB asset by asset_id (settled, future, spendable, off-chain).', { asset_id: { type: 'string', description: "RGB asset id, e.g. 'rgb:2JEUOrsc-…'" } }, ['asset_id']),
+  t('rln', 'rln_refresh_transfers', 'Refresh pending RGB transfers so balances and transfer status are up to date.'),
+  t('rln', 'rln_get_address', 'Get an on-chain BTC address of the RLN node for deposits.'),
+  t('rln', 'rln_send_btc', 'Send on-chain BTC from the RLN node.', { address: { type: 'string', description: 'Destination Bitcoin address' }, amount_sat: { type: 'number', description: 'Amount in satoshis' }, fee_rate: { type: 'number', description: 'sat/vbyte (default 3)' } }, ['address', 'amount_sat'], true),
+  t('rln', 'rln_list_payments', 'List recent Lightning payments (sent and received) on the RLN node.', { limit: { type: 'number', description: 'Max payments (default 20)' } }),
+  t('rln', 'rln_connect_peer', 'Connect the RLN node to a Lightning peer.', { peer_pubkey_and_addr: { type: 'string', description: 'pubkey@host:port' } }, ['peer_pubkey_and_addr']),
+  t('rln', 'rln_open_channel', 'Open a Lightning channel, optionally allocating an RGB asset to it.', {
+    peer_pubkey_and_addr: { type: 'string', description: 'pubkey@host:port' },
+    capacity_sat: { type: 'number', description: 'Channel capacity in satoshis' },
+    push_msat: { type: 'number', description: 'Millisatoshis pushed to the peer (default 0)' },
+    asset_id: { type: 'string', description: 'RGB asset id to allocate' },
+    asset_amount: { type: 'number', description: 'RGB asset amount to allocate' },
+    is_public: { type: 'boolean', description: 'Announce the channel (default false)' },
+  }, ['peer_pubkey_and_addr', 'capacity_sat'], true),
+  t('rln', 'rln_close_channel', 'Close a Lightning channel (force only for an unresponsive peer).', { channel_id: { type: 'string' }, peer_pubkey: { type: 'string' }, force: { type: 'boolean', description: 'Unilateral close (default false)' } }, ['channel_id', 'peer_pubkey'], true),
+  t('rln', 'rln_get_channel_id', 'Resolve a temporary_channel_id from rln_open_channel to the final channel_id.', { temporary_channel_id: { type: 'string' } }, ['temporary_channel_id']),
+  t('rln', 'rln_atomic_taker', 'Whitelist a maker swap on the node (taker side). Pass the swapstring from kaleidoswap_atomic_init, before kaleidoswap_atomic_execute.', { swapstring: { type: 'string' } }, ['swapstring'], true),
+  t('rln', 'rln_list_swaps', 'List atomic swaps on the RLN node (maker and taker sides).'),
+  t('rln', 'rln_get_swap', 'Get an atomic swap by payment_hash.', { payment_hash: { type: 'string' }, taker: { type: 'boolean', description: 'Taker-side swap' } }, ['payment_hash']),
+  t('rln', 'rln_list_transfers', 'List RGB transfers for one asset (issuance, sends, receives) with their status — use to check if an RGB invoice was paid.', { asset_id: { type: 'string', description: 'RGB asset id (in-app wallets also accept a ticker)' } }, ['asset_id']),
+  // Issuance + UTXO prep spend on-chain BTC and are irreversible → gated like any spend.
+  t('rln', 'rln_create_utxos', 'Create colorable UTXOs on the RLN node — needed before issuing or receiving RGB assets on a fresh node.', {
+    num: { type: 'number', description: 'How many UTXOs (default 5)' },
+    size: { type: 'number', description: 'Size of each UTXO in sats (default: node decides)' },
+    up_to: { type: 'boolean', description: 'Only top up to `num` free UTXOs (default false)' },
+    fee_rate: { type: 'number', description: 'sat/vbyte (default 1)' },
+  }, [], true),
+  t('rln', 'rln_issue_asset', 'Issue a NEW RGB asset owned by this node (e.g. an event ticket or loyalty token).', {
+    schema: { type: 'string', enum: ['NIA', 'CFA', 'UDA'], description: 'NIA = token (default), CFA = collectible, UDA = unique/NFT' },
+    name: { type: 'string', description: 'Asset name, e.g. "Hackathon Ticket"' },
+    ticker: { type: 'string', description: 'Uppercase ticker, e.g. "TICKET". Required for NIA and UDA' },
+    amount: { type: 'number', description: 'Total supply in display units. Required for NIA and CFA; UDA is always 1' },
+    precision: { type: 'number', description: 'Decimal places (default 0)' },
+    details: { type: 'string', description: 'Optional description (CFA and UDA)' },
+  }, ['name'], true),
 
   // ── Arkade ─────────────────────────────────────────────────────────────
   t('arkade', 'arkade_get_balance', 'Get the Arkade wallet balance.'),