@kaleidorg/mind 0.6.4 → 0.8.0

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;
@@ -40,10 +41,11 @@ export interface QvacProviderOptions {
   /** Default max output tokens — caps a turn so it can't ramble. Omit for uncapped. */
   defaultMaxTokens?: number;
   /**
-   * Cap `<think>` reasoning at this many TOKENS (not seconds — tok/s varies, and
-   * the SDK has no numeric reasoning budget). When a turn's thinking exceeds it,
-   * the run is cancelled and a short fallback is returned instead of hanging on
-   * "Thinking…". Omit for unlimited reasoning.
+   * 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.
    */
   maxThinkingTokens?: number;
   /** Stream the model's `<think>` reasoning, when a host wants to surface it. */
@@ -82,31 +84,33 @@ 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.
       const temp = input.temperature ?? options.defaultTemperature;
       const predict = input.maxTokens ?? options.defaultMaxTokens;
-      const generationParams =
-        temp !== undefined || predict !== undefined
-          ? {
-              ...(temp !== undefined ? { temp } : {}),
-              ...(predict !== undefined ? { predict } : {}),
-            }
-          : undefined;
+      // A thinking budget at or above the output cap never binds: the model can
+      // spend the whole turn reasoning and return no answer. Keep half for it.
+      const thinkingCap = input.maxThinkingTokens ?? options.maxThinkingTokens;
+      const maxThinkingTokens =
+        thinkingCap !== undefined && predict !== undefined && thinkingCap >= predict
+          ? Math.floor(predict / 2)
+          : thinkingCap;
+      // `tool_choice` is only meaningful with tools; the SDK rejects a named
+      // choice that isn't among them.
+      const toolChoice = tools && input.toolChoice ? input.toolChoice : undefined;
+      const generationParamsRaw = {
+        ...(temp !== undefined ? { temp } : {}),
+        ...(predict !== undefined ? { predict } : {}),
+        ...(maxThinkingTokens !== undefined ? { reasoning_budget: maxThinkingTokens } : {}),
+        ...(toolChoice ? { tool_choice: toolChoice } : {}),
+      };
+      const generationParams = Object.keys(generationParamsRaw).length ? generationParamsRaw : undefined;
 
       const run = options.completion({
         modelId,
@@ -136,11 +140,13 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
         }
       }
 
-      const maxThinkingTokens = input.maxThinkingTokens ?? options.maxThinkingTokens;
       const result = await consumeRun(run, {
         onToken: input.onToken,
         onThinking: input.onThinking ?? options.onThinking,
-        maxThinkingTokens,
+        // 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: () => {
@@ -155,8 +161,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,
@@ -179,12 +188,16 @@ export function createQvacProvider(options: QvacProviderOptions): LLMProvider {
         ...(result.stopReason ? { stopReason: result.stopReason } : {}),
       };
 
+      const incomplete =
+        !result.text && result.toolCalls.length === 0 && (result.thinkingBudgetExceeded || !!result.truncated);
       return {
         text,
         rawContent: result.rawContent,
         toolCalls: result.toolCalls,
+        ...(result.toolErrors ? { toolErrors: result.toolErrors } : {}),
         requestId: result.requestId,
         inference,
+        ...(incomplete ? { incomplete: true } : {}),
       };
     },
 

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

@@ -28,11 +28,9 @@ export interface StreamHandlers {
   /** The model's `<think>` reasoning, streamed separately. */
   onThinking?: (token: string) => void;
   /**
-   * Cap the `<think>` reasoning at this many tokens. The cap is on TOKENS, not
-   * wall-clock seconds — tok/s varies by model and hardware, so a time budget is
-   * unreliable; the SDK has no numeric reasoning budget (`reasoning_budget` is
-   * only on/off), so we count thinking tokens and stop the run once they exceed
-   * this. Omit for unlimited reasoning.
+   * 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.
    */
   maxThinkingTokens?: number;
   /**
@@ -55,6 +53,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 +115,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,116 @@
+/**
+ * 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);
+}
+
+/**
+ * JSON Schema for a tool's parameters: a JSON-Schema def is returned as is
+ * (nested objects intact), a Zod schema is converted to a flat object schema.
+ */
+export function toolParametersSchema(t: Pick<ToolDef, 'name' | 'description' | 'parameters'>): Record<string, unknown> {
+  const p = t.parameters as Obj | null | undefined;
+  if (p && typeof p === 'object' && !isZodLike(p) && ('properties' in p || p.type === 'object')) return p;
+  return toQvacTool(t).parameters;
+}

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

@@ -0,0 +1,131 @@
+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('extractIssueAsset — review regressions', () => {
+  it('reads thousands separators in both styles, and decimals with k/m', () => {
+    expect(extractIssueAsset('crea 1.000 token CAFE chiamati Caffè Club')).toMatchObject({ amount: 1000, ticker: 'CAFE', name: 'Caffè Club' });
+    expect(extractIssueAsset('issue 1,000 TICKET tokens')).toMatchObject({ amount: 1000 });
+    expect(extractIssueAsset('mint 1,5k PIZZA tokens')).toMatchObject({ amount: 1500 });
+    expect(extractIssueAsset('mint 1.5k PIZZA tokens')).toMatchObject({ amount: 1500 });
+  });
+  it('never takes the supply from a number inside the name', () => {
+    expect(extractIssueAsset('mint tokens named Web3 Summit 2026, supply 300')).toMatchObject({ name: 'Web3 Summit 2026', amount: 300 });
+    expect(extractIssueAsset('mint tokens named Web3 Summit 2026')).toMatchObject({ name: 'Web3 Summit 2026', amount: undefined });
+    expect(issueAssetRecipe.confident!(extractIssueAsset('mint tokens named Web3 Summit 2026')!)).toBe(false);
+    expect(extractIssueAsset('launch a token called Moon with ticker MOON and 1m supply')).toMatchObject({ name: 'Moon', ticker: 'MOON', amount: 1_000_000 });
+  });
+  it('only fires when the request opens with the verb', () => {
+    expect(issueAssetRecipe.match!('I have an issue with my USDT tokens')).toBe(false);
+    expect(issueAssetRecipe.match!('how do I create a token?')).toBe(false);
+    expect(extractIssueAsset('I have an issue with my USDT tokens')).toBeNull();
+    expect(issueAssetRecipe.match!('please mint 100 PIZZA tokens')).toBe(true);
+    expect(issueAssetRecipe.match!('puoi creare 100 token CAFE?')).toBe(true);
+  });
+  it('apostrophes inside a name are not quotes', () => {
+    expect(extractIssueAsset("mint 100 tokens called Joe's Pizza with ticker 'JOE'")).toEqual({ name: "Joe's Pizza", ticker: 'JOE', amount: 100, schema: 'NIA' });
+    expect(extractIssueAsset("crea 50 token chiamati Bottega dell'Arte con ticker ARTE")).toMatchObject({ name: "Bottega dell'Arte", ticker: 'ARTE', amount: 50 });
+    expect(extractIssueAsset('mint 10 tokens "Pizza Points" ticker PP')).toMatchObject({ name: 'Pizza Points', ticker: 'PP', amount: 10 });
+  });
+});
+
+describe('MockWallet.reset', () => {
+  it('restores the initial state, including issued assets and UTXOs', async () => {
+    const wallet = new MockWallet({ utxos: 1 });
+    await wallet.registry().execute('rln_issue_asset', { name: 'Ticket', ticker: 'TICKET', amount: 10 });
+    expect(wallet.utxos).toBe(0);
+    wallet.reset();
+    expect(wallet.utxos).toBe(1);
+    expect(wallet.assets.TICKET).toBeUndefined();
+    await expect(wallet.registry().execute('rln_issue_asset', { name: 'Ticket', ticker: 'TICKET', amount: 10 })).resolves.toMatchObject({ issued: true });
+  });
+});
+
+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');
+  });
+});