@kaleidorg/mind 0.6.3 → 0.7.0

package/src/qvac/provider.test.ts

@@ -77,6 +77,18 @@ describe('createQvacProvider.runTurn', () => {
     expect(params.generationParams).toEqual({ temp: 0.9, predict: 99 });
   });
 
+  it('sends JSON-Schema tools in the SDK Tool shape so arguments survive', async () => {
+    const { fn, calls } = fakeCompletion({ contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' } });
+    const p = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1' });
+    await p.runTurn({
+      messages: [{ role: 'user', content: 'x' }],
+      tools: [{ name: 'echo', description: 'e', parameters: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } }],
+    });
+    expect(calls[0].tools).toEqual([
+      { type: 'function', name: 'echo', description: 'e', parameters: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } },
+    ]);
+  });
+
   it('omits generationParams when no temperature/maxTokens is set (keeps SDK defaults)', async () => {
     const { fn, calls } = fakeCompletion({ contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' } });
     const p = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1' });
@@ -101,6 +113,32 @@ describe('createQvacProvider.runTurn', () => {
     expect(out.text).toMatch(/thinking budget/i);
   });
 
+  it('returns a cancelled turn when the SDK rejects final on abort', async () => {
+    const cancel = vi.fn(async () => {});
+    const fn = () => ({
+      requestId: 'req-a',
+      events: (async function* () {})(),
+      final: Promise.reject(Object.assign(new Error('cancelled'), { requestId: 'req-a', partial: {} })),
+    });
+    const ac = new AbortController();
+    ac.abort();
+    const p = createQvacProvider({ completion: fn as any, cancel: cancel as any, getModelId: () => 'm1' });
+    const out = await p.runTurn({ messages: [{ role: 'user', content: 'x' }], tools: [], signal: ac.signal });
+    expect(cancel).toHaveBeenCalledWith({ requestId: 'req-a' });
+    expect(out.inference?.status).toBe('cancelled');
+    expect(out.toolCalls).toEqual([]);
+  });
+
+  it('derives token counts from the SDK generatedTokens stat', async () => {
+    const { fn } = fakeCompletion({
+      contentText: 'ok', toolCalls: [], raw: { fullText: 'ok' },
+      stats: { promptTokens: 100, generatedTokens: 20, tokensPerSecond: 12, backendDevice: 'gpu' },
+    });
+    const p = createQvacProvider({ completion: fn as any, cancel: noopCancel, getModelId: () => 'm1' });
+    const out = await p.runTurn({ messages: [{ role: 'user', content: 'x' }], tools: [] });
+    expect(out.inference).toMatchObject({ promptTokens: 100, totalTokens: 120, completionTokens: 20, backendDevice: 'gpu' });
+  });
+
   it('streams visible content tokens to onToken', async () => {
     const { fn } = fakeCompletion(
       { contentText: 'Hi there', toolCalls: [], raw: { fullText: 'Hi there' } },

package/src/qvac/provider.ts

@@ -20,6 +20,7 @@ import type * as QvacSdk from '@qvac/sdk';
 import type { InferenceMetrics, LLMProvider, TurnInput, TurnOutput } from '../providers/types.js';
 import type { QvacTurnStats } from './parse.js';
 import { consumeRun } from './stream.js';
+import { toQvacTools } from './tools.js';
 
 type CompletionFn = typeof QvacSdk.completion;
 type CancelFn = typeof QvacSdk.cancel;
@@ -82,19 +83,11 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
         ? [{ role: 'system', content: input.system }, ...input.messages]
         : input.messages;
 
-      // Tools are forwarded by schema only (name/description/parameters). We
-      // carry `parameters` through verbatim (Zod for in-process tools, JSON
-      // Schema for MCP) — the model only needs the shape to pick a call; the
-      // Engine validates + executes.
-      const tools = input.tools.length
-        ? input.tools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters,
-          }))
-        : undefined;
-
-      // QVAC 0.13 nests sampling under `generationParams`; top-level
+      // Tools are forwarded by schema only — the Engine validates + executes.
+      // JSON-Schema tools are normalised to the SDK's Tool shape (see tools.ts).
+      const tools = toQvacTools(input.tools);
+
+      // QVAC (0.13+) nests sampling under `generationParams`; top-level
       // `temperature`/`max_tokens` (as older rate code passed) are dropped by
       // validation, so the cap silently no-op'd. Build it here, and only send it
       // when a value is set so a host that passes neither keeps SDK defaults.
@@ -119,6 +112,23 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
         ...(tools ? { tools } : {}),
       } as unknown as Parameters<CompletionFn>[0]);
 
+      // Honor an external AbortSignal (e.g. the desktop "stop" button): cancel
+      // the in-flight run the moment it fires. The SDK keeps generating
+      // otherwise; `final` then resolves with stopReason 'cancelled'. This is
+      // the single place that makes signal-based cancellation work for EVERY
+      // caller (agentic loop + recipe slot extraction).
+      if (input.signal) {
+        if (input.signal.aborted) {
+          void options.cancel({ requestId: run.requestId }).catch(() => {});
+        } else {
+          input.signal.addEventListener(
+            'abort',
+            () => void options.cancel({ requestId: run.requestId }).catch(() => {}),
+            { once: true },
+          );
+        }
+      }
+
       const maxThinkingTokens = input.maxThinkingTokens ?? options.maxThinkingTokens;
       const result = await consumeRun(run, {
         onToken: input.onToken,
@@ -138,8 +148,11 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
       // instead of an empty bubble so the agentic loop ends cleanly.
       const text =
         result.text || (result.thinkingBudgetExceeded ? THINKING_BUDGET_FALLBACK : result.text);
-      const totalTokens = result.stats?.totalTokens;
       const promptTokens = result.stats?.promptTokens;
+      const generated = result.stats?.generatedTokens;
+      const totalTokens =
+        result.stats?.totalTokens ??
+        (typeof generated === 'number' && typeof promptTokens === 'number' ? promptTokens + generated : undefined);
       const inference: InferenceMetrics = {
         requestId: result.requestId,
         durationMs: result.timing.durationMs,

package/src/qvac/stream.test.ts

@@ -112,4 +112,32 @@ describe('consumeRun', () => {
     );
     expect(out.timing).toEqual({ ttftMs: 45, durationMs: 90 });
   });
+
+  it('folds a rejected final (InferenceCancelledError) into a cancelled turn', async () => {
+    class InferenceCancelledError extends Error {
+      constructor(readonly requestId: string, readonly partial: { text?: string }) {
+        super('cancelled');
+      }
+    }
+    const run: CompletionRunLike = {
+      requestId: 'req-c',
+      events: (async function* () {
+        yield { type: 'contentDelta', text: 'Partial' };
+      })(),
+      final: Promise.reject(new InferenceCancelledError('req-c', { text: 'Partial' })),
+    };
+    const out = await consumeRun(run);
+    expect(out.stopReason).toBe('cancelled');
+    expect(out.text).toBe('Partial');
+    expect(out.toolCalls).toEqual([]);
+  });
+
+  it('re-throws a rejected final that is not a cancellation', async () => {
+    const run: CompletionRunLike = {
+      requestId: 'req-e',
+      events: (async function* () {})(),
+      final: Promise.reject(new Error('boom')),
+    };
+    await expect(consumeRun(run)).rejects.toThrow('boom');
+  });
 });

package/src/qvac/stream.ts

@@ -55,6 +55,28 @@ export interface ConsumedTurn extends ParsedTurn {
   };
 }
 
+/**
+ * Since QVAC 0.11 a cancelled run ends `events` normally but REJECTS `final`
+ * with `InferenceCancelledError { requestId, partial }`. Fold that back into a
+ * `final` frame with stopReason 'cancelled' so a stop or a blown thinking budget
+ * is a result, not an exception. Matched structurally to stay SDK-free.
+ */
+function cancelledFinal(err: unknown): QvacFinalLike | null {
+  const e = err as {
+    requestId?: unknown;
+    partial?: { text?: string; toolCalls?: QvacFinalLike['toolCalls']; stats?: QvacFinalLike['stats'] };
+  } | null;
+  const named = (err as { constructor?: { name?: string } } | null)?.constructor?.name === 'InferenceCancelledError';
+  if (!e || !(named || (typeof e.requestId === 'string' && typeof e.partial === 'object'))) return null;
+  const partial = e.partial ?? {};
+  return {
+    contentText: partial.text ?? '',
+    toolCalls: partial.toolCalls ?? [],
+    ...(partial.stats ? { stats: partial.stats } : {}),
+    stopReason: 'cancelled',
+  };
+}
+
 /** Rough token estimate (~4 chars/token) — same heuristic the context budget uses. */
 function approxTokens(chars: number): number {
   return Math.ceil(chars / 4);
@@ -95,7 +117,14 @@ export async function consumeRun(
       }
     }
   }
-  const final = await run.final;
+  let final: QvacFinalLike;
+  try {
+    final = await run.final;
+  } catch (err) {
+    const recovered = cancelledFinal(err);
+    if (!recovered) throw err;
+    final = recovered;
+  }
   const finishedAt = now();
   return {
     ...finalToTurn(final, streamed),

package/src/qvac/tools.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from 'vitest';
+import { toQvacTools } from './tools.js';
+import { WALLET_TOOLS } from '../wallet/contract.js';
+
+describe('toQvacTools', () => {
+  it('returns undefined for no tools', () => {
+    expect(toQvacTools([])).toBeUndefined();
+  });
+
+  it('keeps JSON-Schema parameters as a full function tool', () => {
+    const [tool] = toQvacTools([
+      {
+        name: 'rln_send_btc',
+        description: 'send',
+        parameters: {
+          type: 'object',
+          properties: {
+            address: { type: 'string', description: 'Destination' },
+            amount_sat: { type: 'integer' },
+            note: { type: ['string', 'null'] },
+            mode: { anyOf: [{ type: 'null' }, { type: 'boolean' }] },
+            tags: { type: 'array', items: { type: 'string' } },
+            schema: { type: 'string', enum: ['NIA', 'CFA'] },
+          },
+          required: ['address', 'amount_sat', 'ghost'],
+          additionalProperties: false,
+        },
+      },
+    ])!;
+    expect(tool).toEqual({
+      type: 'function',
+      name: 'rln_send_btc',
+      description: 'send',
+      parameters: {
+        type: 'object',
+        properties: {
+          address: { type: 'string', description: 'Destination' },
+          amount_sat: { type: 'integer' },
+          note: { type: 'string' },
+          mode: { type: 'boolean' },
+          tags: { type: 'array' },
+          schema: { type: 'string', enum: ['NIA', 'CFA'] },
+        },
+        required: ['address', 'amount_sat'],
+      },
+    });
+  });
+
+  it('passes an all-Zod tool list through for the SDK to convert', () => {
+    const zodish = { shape: {} };
+    expect(toQvacTools([{ name: 'a', description: 'd', parameters: zodish }])).toEqual([
+      { name: 'a', description: 'd', parameters: zodish },
+    ]);
+  });
+
+  it('converts Zod-like tools when mixed with JSON-Schema tools', () => {
+    const zodish = {
+      shape: {
+        city: { type: 'string', description: 'City' },
+        unit: { type: 'optional', def: { innerType: { type: 'enum', def: { entries: { c: 'c', f: 'f' } } } } },
+      },
+    };
+    const out = toQvacTools([
+      { name: 'weather', description: 'w', parameters: zodish },
+      { name: 'ping', description: 'p', parameters: { type: 'object', properties: {} } },
+    ])!;
+    expect(out[0]).toEqual({
+      type: 'function',
+      name: 'weather',
+      description: 'w',
+      parameters: {
+        type: 'object',
+        properties: { city: { type: 'string', description: 'City' }, unit: { type: 'string', enum: ['c', 'f'] } },
+        required: ['city'],
+      },
+    });
+  });
+
+  it('every wallet contract tool keeps its arguments', () => {
+    const out = toQvacTools(WALLET_TOOLS) as Array<{ name: string; parameters: { properties: object } }>;
+    for (const def of WALLET_TOOLS) {
+      const mapped = out.find((t) => t.name === def.name)!;
+      expect(Object.keys(mapped.parameters.properties)).toEqual(Object.keys((def.parameters as any).properties));
+    }
+  });
+});

package/src/qvac/tools.ts

@@ -0,0 +1,106 @@
+/**
+ * Map engine ToolDefs to the tool shape `completion({ tools })` accepts.
+ *
+ * The SDK picks a mode from the FIRST tool: a full `Tool`
+ * (`{ type: 'function', name, description, parameters: <flat JSON Schema> }`)
+ * or a Zod `ToolInput`. A plain JSON-Schema def without `type: 'function'`
+ * falls into the Zod branch, which reads `parameters.shape` and silently drops
+ * every argument — the model then sees tool names with no parameters. So
+ * JSON-Schema tools (wallet contract, MCP) are normalised to full `Tool`s here.
+ * An all-Zod tool list is passed through for the SDK to convert, as before.
+ */
+import type { ToolDef } from '../types.js';
+
+type PropType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'integer';
+const PROP_TYPES = new Set<PropType>(['string', 'number', 'boolean', 'object', 'array', 'integer']);
+
+export interface QvacToolProp {
+  type: PropType;
+  description?: string;
+  enum?: Array<string | number | boolean | null>;
+}
+
+export interface QvacTool {
+  type: 'function';
+  name: string;
+  description: string;
+  parameters: { type: 'object'; properties: Record<string, QvacToolProp>; required?: string[] };
+}
+
+type Obj = Record<string, any>;
+
+function isZodLike(p: unknown): boolean {
+  const o = p as Obj | null;
+  return !!o && typeof o === 'object' && ('shape' in o || '_def' in o || 'def' in o) && !('properties' in o);
+}
+
+function pickType(s: Obj): PropType {
+  const t = Array.isArray(s.type) ? s.type.find((x: unknown) => x !== 'null') : s.type;
+  if (PROP_TYPES.has(t)) return t;
+  for (const alt of [...(s.anyOf ?? []), ...(s.oneOf ?? [])]) {
+    if (alt && typeof alt === 'object' && alt.type !== 'null') return pickType(alt);
+  }
+  if (Array.isArray(s.enum) && s.enum.length) {
+    const first = typeof s.enum[0];
+    if (first === 'number' || first === 'boolean') return first;
+  }
+  return 'string';
+}
+
+function jsonProp(s: Obj): QvacToolProp {
+  const prop: QvacToolProp = { type: pickType(s ?? {}) };
+  if (typeof s?.description === 'string') prop.description = s.description;
+  if (Array.isArray(s?.enum)) {
+    const values = s.enum.filter((v: unknown) => v === null || ['string', 'number', 'boolean'].includes(typeof v));
+    if (values.length) prop.enum = values;
+  }
+  return prop;
+}
+
+function zodProp(field: Obj): { prop: QvacToolProp; optional: boolean } {
+  const kind = field?.type ?? field?.def?.type ?? 'string';
+  const optional = kind === 'optional';
+  const inner = optional ? field.def?.innerType ?? {} : field;
+  const innerKind = inner.type ?? inner.def?.type ?? 'string';
+  const prop: QvacToolProp = { type: PROP_TYPES.has(innerKind) ? innerKind : 'string' };
+  const description = field.description ?? inner.description;
+  if (description) prop.description = description;
+  const values = inner.def?.values ?? inner.def?.entries;
+  if (Array.isArray(values)) prop.enum = values;
+  else if (values && typeof values === 'object') prop.enum = Object.values(values);
+  return { prop, optional };
+}
+
+function toQvacTool(t: Pick<ToolDef, 'name' | 'description' | 'parameters'>): QvacTool {
+  const p = (t.parameters ?? {}) as Obj;
+  const properties: Record<string, QvacToolProp> = {};
+  const required: string[] = [];
+  if (isZodLike(p)) {
+    const shape = p.shape ?? p.def?.shape ?? {};
+    for (const [key, field] of Object.entries(shape as Obj)) {
+      const { prop, optional } = zodProp(field as Obj);
+      properties[key] = prop;
+      if (!optional) required.push(key);
+    }
+  } else {
+    for (const [key, s] of Object.entries((p.properties ?? {}) as Obj)) properties[key] = jsonProp(s as Obj);
+    for (const key of Array.isArray(p.required) ? p.required : []) if (key in properties) required.push(key);
+  }
+  return {
+    type: 'function',
+    name: t.name,
+    description: t.description ?? '',
+    parameters: { type: 'object', properties, ...(required.length ? { required } : {}) },
+  };
+}
+
+/** Tools for `completion()`; undefined when there are none. */
+export function toQvacTools(
+  tools: ReadonlyArray<Pick<ToolDef, 'name' | 'description' | 'parameters'>>,
+): QvacTool[] | Array<Pick<ToolDef, 'name' | 'description' | 'parameters'>> | undefined {
+  if (!tools.length) return undefined;
+  if (tools.every((t) => isZodLike(t.parameters))) {
+    return tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters }));
+  }
+  return tools.map(toQvacTool);
+}

package/src/recipe/issue-asset.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, vi } from 'vitest';
+import { extractIssueAsset, issueAssetRecipe } from './issue-asset.js';
+import { runRecipe } from './runner.js';
+import { Funnel } from '../funnel.js';
+import { confirmReadback } from '../wallet/confirm.js';
+import { MockWallet, scriptedProvider } from '../testing/index.js';
+
+describe('extractIssueAsset (deterministic Tier-0)', () => {
+  it('ticker + supply + quoted-less name', () => {
+    expect(extractIssueAsset('issue 1000 TICKET tokens called Hackathon Ticket')).toEqual({
+      name: 'Hackathon Ticket', ticker: 'TICKET', amount: 1000, schema: 'NIA',
+    });
+  });
+  it('explicit ticker keyword and k shorthand', () => {
+    expect(extractIssueAsset('mint 21k tokens named "Pizza Points" with ticker pizza')).toEqual({
+      name: 'Pizza Points', ticker: 'PIZZA', amount: 21_000, schema: 'NIA',
+    });
+  });
+  it('NFT → UDA with supply 1, ticker derived from the name', () => {
+    expect(extractIssueAsset('mint an NFT called Genesis Badge')).toEqual({
+      name: 'Genesis Badge', ticker: 'GENESISB', amount: 1, schema: 'UDA',
+    });
+  });
+  it('Italian phrasing', () => {
+    expect(extractIssueAsset('crea 500 token CAFE chiamati Caffè Club')).toEqual({
+      name: 'Caffè Club', ticker: 'CAFE', amount: 500, schema: 'NIA',
+    });
+  });
+  it('ignores invoices, channels, sends and swaps', () => {
+    expect(extractIssueAsset('create an invoice for 10 USDT tokens')).toBeNull();
+    expect(extractIssueAsset('create a channel with 100 USDT')).toBeNull();
+    expect(extractIssueAsset('send 10 tokens to bob')).toBeNull();
+    expect(extractIssueAsset('what is my balance')).toBeNull();
+    expect(issueAssetRecipe.match!('buy 100 USDT tokens')).toBe(false);
+  });
+});
+
+describe('issue-asset readback', () => {
+  it('fungible: supply + ticker + name', () => {
+    expect(confirmReadback({ name: 'rln_issue_asset', arguments: { name: 'Hackathon Ticket', ticker: 'TICKET', amount: 1000 } }))
+      .toBe('Issue 1,000 TICKET (Hackathon Ticket), a new RGB asset. Confirm?');
+  });
+  it('UDA: unique asset wording', () => {
+    expect(confirmReadback({ name: 'rln_issue_asset', arguments: { name: 'Genesis Badge', ticker: 'GENESISB', amount: 1, schema: 'UDA' } }))
+      .toBe('Issue unique asset GENESISB (Genesis Badge) on RGB. Confirm?');
+  });
+});
+
+describe('runRecipe — issue asset against MockWallet', () => {
+  it('one confirmation, asset lands in the wallet', async () => {
+    const wallet = new MockWallet();
+    const onConfirm = vi.fn(async () => ({ approved: true }));
+    const res = await runRecipe(issueAssetRecipe, 'issue 1000 TICKET tokens called Hackathon Ticket', {
+      provider: scriptedProvider(), tools: wallet.registry(), onConfirm,
+    });
+    expect(res.status).toBe('done');
+    expect(res.inferences).toBe(0);
+    expect(onConfirm).toHaveBeenCalledOnce();
+    expect(wallet.assets.TICKET).toBe(1000);
+    expect(res.text).toMatch(/^Issued 1000 TICKET\. Asset id: rgb:mock-ticket-/);
+  });
+
+  it('declined confirmation issues nothing', async () => {
+    const wallet = new MockWallet();
+    const res = await runRecipe(issueAssetRecipe, 'issue 1000 TICKET tokens', {
+      provider: scriptedProvider(), tools: wallet.registry(), onConfirm: async () => ({ approved: false }),
+    });
+    expect(res.status).toBe('cancelled');
+    expect(wallet.assets.TICKET).toBeUndefined();
+  });
+
+  it('surfaces the node-style "no UTXOs" failure', async () => {
+    const wallet = new MockWallet({ utxos: 0 });
+    const res = await runRecipe(issueAssetRecipe, 'issue 1000 TICKET tokens', {
+      provider: scriptedProvider(), tools: wallet.registry(), onConfirm: async () => ({ approved: true }),
+    });
+    expect(res.status).toBe('error');
+    expect(res.error ?? res.text).toMatch(/rln_create_utxos/);
+  });
+});
+
+describe('Funnel — issue-asset as an opt-in recipe', () => {
+  it('routes to the recipe tier and is listable afterwards', async () => {
+    const wallet = new MockWallet();
+    const funnel = new Funnel({ provider: scriptedProvider(), tools: wallet.registry(), recipes: [issueAssetRecipe] });
+    const out = await funnel.runTurn('mint an NFT called Genesis Badge', { onConfirm: async () => ({ approved: true }) });
+    expect(out.tier).toBe('recipe');
+    expect(out.route).toBe('issue-asset');
+    const listed = (await wallet.registry().execute('rln_list_assets', {})) as { assets: Array<{ ticker: string; schema: string }> };
+    expect(listed.assets.find((a) => a.ticker === 'GENESISB')?.schema).toBe('UDA');
+  });
+});

package/src/recipe/issue-asset.ts

@@ -0,0 +1,95 @@
+/**
+ * "Issue an RGB asset" recipe — the hackathon one-liner:
+ *
+ *   "issue 1000 TICKET tokens called Hackathon Ticket"  → rln_issue_asset 🔒
+ *   "mint an NFT called Genesis Badge"                  → rln_issue_asset 🔒 (UDA)
+ *   "crea 500 token CAFE chiamati Caffè Club"           → rln_issue_asset 🔒
+ *
+ * No intermediate steps: the plan is a single gated call, so the recipe's job
+ * is the slot extraction (name / ticker / supply / schema) and a deterministic
+ * readback — exactly the part a 0.6B model gets wrong. Opt-in: register via
+ * `Funnel.recipes` on hosts that bind `rln_issue_asset`.
+ */
+
+import type { Recipe, RecipeContext } from './types.js';
+
+const VERB = /\b(issue|mint|create|launch|emetti|conia|crea)\b/i;
+const NOUN = /\b(tokens?|assets?|coins?|nfts?|tickets?|gettoni|badges?)\b/i;
+const NOT_ISSUE = /\b(invoice|fattura|channel|canale|swap|buy|sell|send|pay|compra|vendi|invia|paga)\b/i;
+const NFT = /\b(nfts?|unique|unico|unica)\b/i;
+// Words that look like tickers but are part of the request, not the asset.
+const STOPWORDS = new Set(['RGB', 'NFT', 'NFTS', 'NIA', 'CFA', 'UDA', 'BTC', 'LN', 'AN', 'A']);
+
+function parseAmount(t: string): number | undefined {
+  const m = t.match(/(?:^|\s)(\d[\d.,]*)\s*([km])?(?=\s|$)/i);
+  if (!m) return undefined;
+  let n = Number(m[1]!.replace(/,/g, ''));
+  if (m[2]) n *= m[2].toLowerCase() === 'k' ? 1_000 : 1_000_000;
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
+function parseName(t: string): string | undefined {
+  const quoted = t.match(/["“'‘]([^"”'’]{1,40})["”'’]/)?.[1];
+  if (quoted) return quoted.trim();
+  const m = t.match(/\b(?:called|named|chiamat[oaie])\s+(.+?)(?=\s+(?:with|ticker|con)\b|[,.;]|$)/i);
+  return m?.[1]?.trim() || undefined;
+}
+
+function parseTicker(t: string, name?: string): string | undefined {
+  const explicit = t.match(/\bticker\s+([A-Za-z0-9]{1,8})\b/i)?.[1];
+  if (explicit) return explicit.toUpperCase();
+  // An all-caps word that isn't part of the name ("1000 TICKET tokens").
+  const nameWords = new Set((name ?? '').split(/\s+/));
+  for (const w of t.match(/\b[A-Z][A-Z0-9]{1,7}\b/g) ?? []) {
+    if (!STOPWORDS.has(w) && !nameWords.has(w)) return w;
+  }
+  return undefined;
+}
+
+/** Ticker fallback from the name: "Hackathon Ticket" → "HACKATHO". */
+function tickerFromName(name: string): string {
+  return name.replace(/[^A-Za-z0-9]/g, '').toUpperCase().slice(0, 8);
+}
+
+export function extractIssueAsset(text: string): Record<string, unknown> | null {
+  const t = text.trim();
+  if (!VERB.test(t) || !NOUN.test(t) || NOT_ISSUE.test(t)) return null;
+  const schema = NFT.test(t) ? 'UDA' : 'NIA';
+  const name = parseName(t);
+  const ticker = parseTicker(t, name) ?? (name ? tickerFromName(name) : undefined);
+  const amount = schema === 'UDA' ? 1 : parseAmount(t);
+  if (!ticker && !name) return null;
+  return { name: name ?? ticker, ticker, amount, schema };
+}
+
+export const issueAssetRecipe: Recipe = {
+  name: 'issue-asset',
+  description: 'Issue a new RGB asset (token, ticket, NFT) on the RLN node — one confirmation-gated call.',
+  match: (t) => VERB.test(t) && NOUN.test(t) && !NOT_ISSUE.test(t),
+  triggers: ['issue', 'mint', 'create token', 'launch token', 'nft'],
+  slots: [
+    { name: 'name', type: 'string', description: 'Asset name, e.g. "Hackathon Ticket"', required: true },
+    { name: 'ticker', type: 'string', description: 'Uppercase ticker, up to 8 chars, e.g. "TICKET"' },
+    { name: 'amount', type: 'number', description: 'Total supply in whole units (1 for an NFT)', required: true },
+    { name: 'schema', type: 'string', description: 'NIA for a fungible token, UDA for a unique NFT' },
+  ],
+  extract: extractIssueAsset,
+  confident: (s) => !!(s.ticker || s.name) && Number(s.amount) > 0,
+  steps: [],
+  final: {
+    tool: 'rln_issue_asset',
+    args: (ctx: RecipeContext) => {
+      const name = String(ctx.slots.name ?? ctx.slots.ticker);
+      const ticker = String(ctx.slots.ticker ?? tickerFromName(name)).toUpperCase();
+      const schema = ctx.slots.schema === 'UDA' ? 'UDA' : 'NIA';
+      return { name, ticker, amount: schema === 'UDA' ? 1 : Number(ctx.slots.amount), schema };
+    },
+  },
+  summary: (ctx, final) => {
+    // wdk/kaleido MCP return `asset_id` flat; the raw node API nests it under `asset`.
+    const r = final as { asset_id?: string; asset?: { asset_id?: string } } | undefined;
+    const id = r?.asset_id ?? r?.asset?.asset_id;
+    const what = ctx.slots.schema === 'UDA' ? `unique asset ${ctx.slots.ticker ?? ctx.slots.name}` : `${ctx.slots.amount} ${ctx.slots.ticker ?? ctx.slots.name}`;
+    return id ? `Issued ${what}. Asset id: ${id}` : `Issued ${what}.`;
+  },
+};

package/src/recipe/kaleidoswap-atomic.test.ts

@@ -156,6 +156,33 @@ describe('kaleidoswapAtomicRecipe — forceModelExtract (less deterministic slot
       from_layer: 'BTC_LN', to_layer: 'RGB_LN', to_amount: 1,
     });
   });
+
+  it('stops the chain (status cancelled) when the abort signal fires during extraction', async () => {
+    // The stop button aborts the signal mid-inference. extractSlots must NOT
+    // paper over an explicit cancel with deterministic slots — the recipe must
+    // report cancelled and run NO steps (nothing sent).
+    const captured: { name: string; args: any }[] = [];
+    const tools = buildStubs(captured);
+    const ctrl = new AbortController();
+    const abortingProvider: LLMProvider = {
+      name: 'aborting',
+      runTurn: async () => {
+        ctrl.abort(); // simulate the user pressing stop while the model runs
+        throw new Error('Inference request "x" was cancelled before it could complete');
+      },
+    };
+
+    const res = await runRecipe(kaleidoswapAtomicRecipe, 'buy 1 usdt', {
+      provider: abortingProvider,
+      tools,
+      onConfirm: async () => ({ approved: true }),
+      signal: ctrl.signal,
+    });
+
+    expect(res.status).toBe('cancelled');
+    expect(res.text).toBe('Stopped.');
+    expect(captured).toHaveLength(0); // nothing ran — not even the read-only quote
+  });
 });
 
 describe('kaleidoswapAtomicRecipe — full chain', () => {