@webmcp-auto-ui/agent 2.5.5 → 2.5.7

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@webmcp-auto-ui/agent",
-  "version": "2.5.5",
+  "version": "2.5.7",
   "description": "LLM agent loop + Anthropic/Gemma LiteRT providers + MCP wrapper",
   "license": "AGPL-3.0-or-later",
   "type": "module",
+  "sideEffects": true,
   "main": "./src/index.ts",
   "exports": {
     ".": {

package/src/auto-repair.ts

@@ -82,8 +82,8 @@ export function autoRepairParams(
         params[req] = propSchema.default;
         fixes.push(`${req}: missing required → default ${JSON.stringify(propSchema.default)}`);
       }
-      // If enum with single value, use it
-      if (propSchema.enum && (propSchema.enum as unknown[]).length === 1) {
+      // If enum with single value, use it (only if not already filled by default above)
+      else if (propSchema.enum && (propSchema.enum as unknown[]).length === 1) {
         params[req] = (propSchema.enum as unknown[])[0];
         fixes.push(`${req}: missing required → single enum ${JSON.stringify(params[req])}`);
       }

package/src/diagnostics.ts

@@ -23,6 +23,8 @@ export function runDiagnostics(
   tools: ProviderTool[],
   systemPrompt: string,
   schemaOptions?: { sanitize?: boolean; flatten?: boolean },
+  /** Original (pre-sanitize) tools — used for check #5 to detect patchable schemas */
+  rawTools?: ProviderTool[],
 ): Diagnostic[] {
   const diagnostics: Diagnostic[] = [];
 
@@ -102,7 +104,9 @@ export function runDiagnostics(
   }
 
   // 5. Strict mode — schemas that were auto-patched
-  for (const tool of tools) {
+  // Must run on raw (pre-sanitize) schemas; sanitized tools will never show patches.
+  const checkTools = rawTools ?? tools;
+  for (const tool of checkTools) {
     const { patches } = sanitizeSchemaWithReport(tool.input_schema as JsonSchema);
     if (patches.length > 0) {
       diagnostics.push({

package/src/index.ts

@@ -26,7 +26,7 @@ export { autoui, NATIVE_WIDGET_NAMES } from './autoui-server.js';
 
 // Tool layers
 export { buildToolsFromLayers, buildDiscoveryTools, buildDiscoveryToolsWithAliases, activateServerTools, resolveCanonicalTools, toolAliasMap, buildSystemPromptWithAliases, flattenPathMaps, buildDiscoveryCache } from './tool-layers.js';
-export type { ToolLayer, McpLayer, WebMcpLayer, SystemPromptResult, DiscoveryToolsResult, SchemaTransformOptions } from './tool-layers.js';
+export type { ToolLayer, McpLayer, WebMcpLayer, SystemPromptResult, DiscoveryToolsResult, SchemaTransformOptions, BuildToolsResult } from './tool-layers.js';
 
 // Discovery cache
 export { DiscoveryCache } from './discovery-cache.js';
@@ -55,6 +55,9 @@ export type { Diagnostic } from './diagnostics.js';
 export { autoRepairParams } from './auto-repair.js';
 export type { RepairResult } from './auto-repair.js';
 
+// Pipeline trace
+export { PipelineTrace, type TraceEntry } from './pipeline-trace.js';
+
 // Nano-RAG — context compaction
 export { ContextRAG, type ContextRAGOptions } from './nano-rag/mod.js';
 

package/src/loop.ts

@@ -9,11 +9,12 @@ import type {
   LLMProvider, ProviderTool, McpToolDef, AgentCallbacks,
 } from './types.js';
 import type { ToolLayer, SchemaTransformOptions } from './tool-layers.js';
-import { buildToolsFromLayers, buildSystemPromptWithAliases, buildDiscoveryToolsWithAliases, buildSystemPrompt, buildDiscoveryTools, activateServerTools, toProviderTools, sanitizeServerName, flattenPathMaps } from './tool-layers.js';
+import { buildToolsFromLayers, buildSystemPromptWithAliases, buildDiscoveryToolsWithAliases, buildSystemPrompt, activateServerTools, toProviderTools, sanitizeServerName, flattenPathMaps } from './tool-layers.js';
 import type { DiscoveryCache } from './discovery-cache.js';
 import { unflattenParams, validateJsonSchema } from '@webmcp-auto-ui/core';
 import type { JsonSchema } from '@webmcp-auto-ui/core';
 import { autoRepairParams } from './auto-repair.js';
+import { PipelineTrace } from './pipeline-trace.js';
 
 // Re-export buildSystemPrompt for backward compat
 export { buildSystemPrompt } from './tool-layers.js';
@@ -160,11 +161,19 @@ export async function runAgentLoop(
   // Use local alias maps (parallel-safe — no global singleton)
   const activatedServers = new Set<string>();
   const localAliasMap = new Map<string, string>();
+  const trace = new PipelineTrace();
 
-  const disc = buildDiscoveryToolsWithAliases(options.layers ?? [], schemaOptions);
+  const disc = buildDiscoveryToolsWithAliases(options.layers ?? [], schemaOptions, trace);
   let activeTools: ProviderTool[] = disc.tools;
   for (const [k, v] of disc.aliasMap) localAliasMap.set(k, v);
 
+  // Log any trace warnings from initial tool build
+  const initTraceSummary = trace.summary();
+  if (initTraceSummary) {
+    callbacks.onTrace?.(`[pipeline-trace] init\n${initTraceSummary}`);
+    trace.clear();
+  }
+
   let baseSystemPrompt: string;
   if (options.systemPrompt) {
     baseSystemPrompt = options.systemPrompt;
@@ -238,7 +247,7 @@ export async function runAgentLoop(
         try {
           const ragResults = await contextRAG.query(queryText);
           if (ragResults.length > 0) {
-            callbacks.onText?.(`[nano-rag] query "${queryText.slice(0, 40)}${queryText.length > 40 ? '…' : ''}" → ${ragResults.length} results (${ragResults.map(r => r.score.toFixed(2)).join(', ')})`);
+            callbacks.onTrace?.(`[nano-rag] query "${queryText.slice(0, 40)}${queryText.length > 40 ? '…' : ''}" → ${ragResults.length} results (${ragResults.map(r => r.score.toFixed(2)).join(', ')})`);
           }
           const ragContext = await contextRAG.buildContext(queryText);
           if (ragContext) {
@@ -371,7 +380,7 @@ export async function runAgentLoop(
 
         // Parse tool name to extract server — activate on first contact
         {
-          const activateMatch = block.name.match(/^(.+?)_(mcp|webmcp)_(.+)$/);
+          const activateMatch = resolvedName.match(/^(.+?)_(mcp|webmcp)_(.+)$/);
           if (activateMatch) {
             const [, serverName, protocol] = activateMatch;
             const serverKey = `${serverName}_${protocol}`;
@@ -379,12 +388,13 @@ export async function runAgentLoop(
               activatedServers.add(serverKey);
               const layer = (options.layers ?? []).find(l => sanitizeServerName(l.serverName) === serverName && l.protocol === protocol);
               if (layer) {
-                activeTools = activateServerTools(activeTools, layer, schemaOptions);
+                activeTools = activateServerTools(activeTools, layer, schemaOptions, trace);
               }
             }
           }
         }
         if (!toolMatch) {
+          trace.push('dispatch', name, `unknown tool format, expected {source}_{protocol}_{tool}`, 'error');
           result = `Error: unknown tool format "${name}". Expected {source}_{protocol}_{tool}.`;
         } else {
           const [, serverName, protocol, realToolName] = toolMatch;
@@ -396,12 +406,16 @@ export async function runAgentLoop(
             const repair = autoRepairParams(toolInput, toolDef.input_schema, realToolName);
             if (repair.fixes.length > 0) {
               toolInput = repair.params;
-              callbacks.onText?.(`[auto-repair] ${repair.fixes.join(', ')}`);
+              callbacks.onTrace?.(`[auto-repair] ${repair.fixes.join(', ')}`);
+              for (const fix of repair.fixes) {
+                trace.push('repair', name, fix, 'warn');
+              }
             }
             // Validate after repair
             const validation = validateJsonSchema(toolInput, toolDef.input_schema as JsonSchema);
             if (!validation.valid) {
               const errors = validation.errors?.map((e: { message?: string }) => e.message ?? String(e)).join(', ') ?? 'unknown';
+              trace.push('validate', name, errors, 'error');
               result = `Validation error: ${errors}. Expected schema: ${JSON.stringify(toolDef.input_schema)}`;
               // Push error as tool_result and skip to next block
               toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: result });
@@ -449,7 +463,7 @@ export async function runAgentLoop(
                 if (realToolName === 'widget_display' && typeof toolResult === 'object' && toolResult !== null) {
                   const wr = toolResult as Record<string, unknown>;
                   if (wr.widget && wr.data && !wr.error) {
-                    const widgetResult = callbacks.onWidget?.(wr.widget as string, wr.data as Record<string, unknown>);
+                    const widgetResult = callbacks.onWidget?.(wr.widget as string, wr.data as Record<string, unknown>, serverName);
                     if (widgetResult?.id) {
                       result = JSON.stringify({ ...wr, id: widgetResult.id });
                     }
@@ -462,7 +476,49 @@ export async function runAgentLoop(
                   const id = (block.input as Record<string, unknown>).id as string;
                   const actionParams = (block.input as Record<string, unknown>).params as Record<string, unknown> | undefined;
                   switch (action) {
-                    case 'clear': callbacks.onClear?.(); break;
+                    case 'clear':
+                      callbacks.onClear?.();
+                      // Strip old widget_display / render_* tool calls AND their
+                      // matching tool_result blocks from the messages array so the
+                      // LLM no longer sees them in context and cannot re-create
+                      // the cleared widgets.
+                      {
+                        const strippedIds = new Set<string>();
+                        // Pass 1: collect IDs of widget tool_use blocks
+                        for (const msg of messages) {
+                          if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+                          for (const b of msg.content as ContentBlock[]) {
+                            if (b.type !== 'tool_use') continue;
+                            const tu = b as { type: 'tool_use'; id: string; name: string };
+                            if (tu.name.includes('widget_display') || tu.name.startsWith('render_')) {
+                              strippedIds.add(tu.id);
+                            }
+                          }
+                        }
+                        // Pass 2: strip tool_use and matching tool_result blocks
+                        if (strippedIds.size > 0) {
+                          for (const msg of messages) {
+                            if (!Array.isArray(msg.content)) continue;
+                            msg.content = (msg.content as ContentBlock[]).filter(b => {
+                              if (b.type === 'tool_use') {
+                                return !strippedIds.has((b as { type: 'tool_use'; id: string }).id);
+                              }
+                              if (b.type === 'tool_result') {
+                                return !strippedIds.has((b as { type: 'tool_result'; tool_use_id: string }).tool_use_id);
+                              }
+                              return true;
+                            });
+                          }
+                          // Remove messages with empty content arrays (orphaned after stripping)
+                          let i = messages.length;
+                          while (i-- > 0) {
+                            const c = messages[i].content;
+                            if (Array.isArray(c) && c.length === 0) messages.splice(i, 1);
+                          }
+                        }
+                        hasRendered = false;
+                      }
+                      break;
                     case 'update': callbacks.onUpdate?.(id, actionParams ?? {}); break;
                     case 'move': callbacks.onMove?.(id, (actionParams?.x ?? (block.input as any).x) as number, (actionParams?.y ?? (block.input as any).y) as number); break;
                     case 'resize': callbacks.onResize?.(id, (actionParams?.width ?? (block.input as any).width) as number, (actionParams?.height ?? (block.input as any).height) as number); break;
@@ -482,8 +538,7 @@ export async function runAgentLoop(
 
         // Nano-RAG: ingest tool result for future context retrieval
         if (contextRAG && result) {
-          const toolMatch2 = resolvedName.match(/^(.+?)_(mcp|webmcp)_(.+)$/);
-          const realName = toolMatch2 ? toolMatch2[3] : block.name;
+          const realName = toolMatch ? toolMatch[3] : block.name;
           const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
           // Find the last user message for contextual embeddings
           const lastUserText = [...messages].reverse()
@@ -493,7 +548,7 @@ export async function runAgentLoop(
             : (lastUserText as any[])?.find((b: any) => b.type === 'text')?.text ?? '';
           contextRAG.ingest(realName, block.id, resultStr, userQuery).then((chunkCount) => {
             if (chunkCount > 0) {
-              callbacks.onText?.(`[nano-rag] ingested ${chunkCount} chunks from ${realName} (${resultStr.length} chars)`);
+              callbacks.onTrace?.(`[nano-rag] ingested ${chunkCount} chunks from ${realName} (${resultStr.length} chars)`);
             }
           }).catch(() => {});
         }
@@ -513,6 +568,13 @@ export async function runAgentLoop(
 
     messages.push({ role: 'user', content: toolResults });
 
+    // Flush pipeline trace warnings to agent console
+    const traceSummary = trace.summary();
+    if (traceSummary) {
+      callbacks.onTrace?.(`[pipeline-trace]\n${traceSummary}`);
+      trace.clear();
+    }
+
     // Track iterations without render — widget_display means a render happened
     const renderedThisIteration = toolBlocks.some(b => {
       const match = b.name.match(/^.+?_(mcp|webmcp)_(.+)$/);

package/src/nano-rag/mod.ts

@@ -2,4 +2,4 @@ export { ContextRAG, type ContextRAGOptions } from './context-rag.js';
 export { chunkToolResult, type Chunk } from './chunker.js';
 export { Embedder, EMBEDDING_DIMS } from './embedder.js';
 export { VectorIndex, type SearchResult, type IndexEntry } from './index.js';
-export { loadQuantizer, type QuantizerInstance } from './quantizer-bridge.js';
+export { loadQuantizer, resetQuantizer, type QuantizerInstance } from './quantizer-bridge.js';

package/src/nano-rag/quantizer-bridge.ts

@@ -113,3 +113,7 @@ export async function loadQuantizer(): Promise<QuantizerInstance> {
 
 	return instance;
 }
+
+export function resetQuantizer(): void {
+	instance = null;
+}

package/src/pipeline-trace.ts

@@ -0,0 +1,32 @@
+/**
+ * PipelineTrace — lightweight tracing for the tool pipeline.
+ * Accumulates what happens at each step (sanitize, flatten, validate, repair, parse, dispatch).
+ * When everything is fine → nothing logged. When a step degrades data → warning visible in agent console.
+ */
+
+export interface TraceEntry {
+  step: string;          // "sanitize", "flatten", "validate", "repair", "parse", "dispatch"
+  tool: string;          // tool name
+  detail: string;        // human-readable description
+  level: 'ok' | 'warn' | 'error';
+}
+
+export class PipelineTrace {
+  entries: TraceEntry[] = [];
+
+  push(step: string, tool: string, detail: string, level: 'ok' | 'warn' | 'error' = 'ok') {
+    this.entries.push({ step, tool, detail, level });
+  }
+
+  get warnings() { return this.entries.filter(e => e.level !== 'ok'); }
+
+  hasErrors() { return this.entries.some(e => e.level === 'error'); }
+
+  summary(): string {
+    const w = this.warnings;
+    if (w.length === 0) return '';
+    return w.map(e => `[${e.step}] ${e.tool}: ${e.detail}`).join('\n');
+  }
+
+  clear() { this.entries.length = 0; }
+}

package/src/providers/wasm.ts

@@ -4,6 +4,7 @@
  * Uses dynamic import() to avoid bundling MediaPipe when only Claude is used.
  */
 import type { LLMProvider, LLMResponse, ChatMessage, AnthropicTool, WasmModelId, ContentBlock } from '../types.js';
+import type { PipelineTrace } from '../pipeline-trace.js';
 
 export type WasmStatus = 'idle' | 'loading' | 'ready' | 'error';
 
@@ -23,6 +24,9 @@ export class WasmProvider implements LLMProvider {
   readonly name = 'wasm';
   readonly model: string;
 
+  /** Optional pipeline trace — set externally to trace parsing strategy fallbacks */
+  trace?: PipelineTrace;
+
   private inference: any = null;  // LlmInference
   private status: WasmStatus = 'idle';
   private opts: WasmProviderOptions;
@@ -222,7 +226,7 @@ export class WasmProvider implements LLMProvider {
     while (messages.length > MAX_MESSAGES) {
       messages = messages.slice(1);
     }
-    prompt = this.buildPrompt(messages, tools, options?.system);
+    prompt = this.buildPrompt(messages, tools, options?.system, options?.maxTools);
 
     // Token-based clipping: if prompt is still too large, drop oldest messages
     const maxPromptTokens = (this.opts.contextSize ?? 4096) - 512;
@@ -235,6 +239,15 @@ export class WasmProvider implements LLMProvider {
       // sizeInTokens not available — skip clipping
     }
 
+    // Count input tokens for usage reporting (TokenBubble Ctx ratio)
+    let inputTokenCount = 0;
+    try {
+      inputTokenCount = this.inference.sizeInTokens(prompt);
+    } catch {
+      // sizeInTokens not available — estimate from char count
+      inputTokenCount = Math.round(prompt.length / 4);
+    }
+
     // Generate
     const t0 = performance.now();
     let fullText = '';
@@ -389,7 +402,10 @@ export class WasmProvider implements LLMProvider {
       // Strategy 2: If no pairs found, try simple replacement + JSON.parse
       if (Object.keys(toolArgs).length === 0) {
         const argsStr = rawArgs.replace(/<\|"\|>/g, '"');
-        try { toolArgs = JSON.parse(argsStr); } catch {
+        try {
+          toolArgs = JSON.parse(argsStr);
+          this.trace?.push('parse', toolName, 'fell back to quote replacement strategy', 'warn');
+        } catch {
           // Strategy 3: regex key:value extraction on replaced string
           try {
             const obj: Record<string, unknown> = {};
@@ -402,7 +418,10 @@ export class WasmProvider implements LLMProvider {
               else if (arrVal !== undefined) { try { obj[k] = JSON.parse(arrVal); } catch { obj[k] = arrVal; } }
               else if (litVal !== undefined) obj[k] = JSON.parse(litVal);
             }
-            if (Object.keys(obj).length > 0) toolArgs = obj;
+            if (Object.keys(obj).length > 0) {
+              toolArgs = obj;
+              this.trace?.push('parse', toolName, 'fell back to regex key:value strategy', 'warn');
+            }
           } catch {}
         }
       }
@@ -492,6 +511,10 @@ export class WasmProvider implements LLMProvider {
         totalTokens: realTokenCount,
         latencyMs,
       },
+      usage: {
+        input_tokens: inputTokenCount,
+        output_tokens: realTokenCount,
+      },
     };
   }
 
@@ -536,8 +559,10 @@ export class WasmProvider implements LLMProvider {
       let i = m.index + m[0].length;
       while (i < raw.length && depth > 0) {
         const ch = raw[i];
-        if (ch === opener || ch === '{' || ch === '[') depth++;
-        else if (ch === closer || ch === '}' || ch === ']') depth--;
+        if (ch === opener) depth++;
+        else if (ch !== opener && (ch === '{' || ch === '[')) depth++;
+        else if (ch === closer) depth--;
+        else if (ch !== closer && (ch === '}' || ch === ']')) depth--;
         i++;
       }
       const fragment = raw.slice(m.index + m[0].length - 1, i); // includes opener and closer

package/src/recipe-registry.ts

@@ -22,13 +22,12 @@ export function registerRecipes(recipes: Recipe[]): void {
 /**
  * Filter recipes that match at least one of the given server names.
  * Uses substring matching: recipe server "tricoteuses" matches connected server
- * "Tricoteuses - Moulineuse" or "tricoteuses-mcp".
+ * "Tricoteuses" or "tricoteuses-mcp".
  */
 // Known aliases: servers that are the same but have different names
 const SERVER_ALIASES: Record<string, string[]> = {
-  'tricoteuses': ['moulineuse', 'code4code', 'mcp.code4code.eu'],
-  'moulineuse': ['tricoteuses', 'code4code', 'mcp.code4code.eu'],
-  'code4code': ['tricoteuses', 'moulineuse', 'mcp.code4code.eu'],
+  'tricoteuses': ['code4code', 'mcp.code4code.eu'],
+  'code4code': ['tricoteuses', 'mcp.code4code.eu'],
 };
 
 export function filterRecipesByServer(recipes: Recipe[], serverNames: string[]): Recipe[] {
@@ -39,7 +38,7 @@ export function filterRecipesByServer(recipes: Recipe[], serverNames: string[]):
     const lower = name.toLowerCase();
     expanded.add(lower);
     for (const alias of SERVER_ALIASES[lower] ?? []) expanded.add(alias);
-    // Also add parts of compound names ("Tricoteuses - Moulineuse" → tricoteuses, moulineuse)
+    // Also add parts of compound names ("Tricoteuses - code4code" → tricoteuses, code4code)
     for (const part of lower.split(/[\s,\-–]+/)) {
       if (part.length > 2) {
         expanded.add(part);
@@ -80,7 +79,7 @@ export function formatMcpRecipesForPrompt(recipes: McpRecipe[]): string {
   return recipes.map(r => {
     const id = r.name ?? '';
     const desc = r.description ?? '';
-    // If name is missing or looks like a prefix ("moulineuse: undefined"), use description as display
+    // If name is missing or looks like a prefix ("tricoteuses: undefined"), use description as display
     if (!id || id.includes('undefined')) {
       return `- ${desc}`;
     }

package/src/recipes/_generated.ts

@@ -49,9 +49,9 @@ Le serveur Met Museum donne acces a la collection du Metropolitan Museum of Art
    \`\`\`
    component("gallery", {
      images: objects
-       .filter(o => o.primaryImage)
+       .filter(o => o.primaryImageSmall)
        .map(o => ({
-         src: o.primaryImage,
+         src: o.primaryImageSmall,
          alt: o.title + " — " + o.artistDisplayName,
          caption: o.objectDate + " | " + o.medium
        }))
@@ -97,7 +97,7 @@ objectIDs.slice(0, 8).forEach(id => get_object({objectID: id}))
 
 // 3. Rendu
 component("stat-card", {label: "Oeuvres de Van Gogh", value: "8", icon: "palette"})
-component("gallery", {images: vanGoghWorks.map(w => ({src: w.primaryImage, alt: w.title, caption: w.objectDate}))})
+component("gallery", {images: vanGoghWorks.map(w => ({src: w.primaryImageSmall, alt: w.title, caption: w.objectDate}))})
 component("cards", {items: vanGoghWorks.map(w => ({title: w.title, subtitle: w.objectDate, image: w.primaryImageSmall, body: w.medium}))})
 \`\`\`
 
@@ -107,7 +107,7 @@ component("cards", {items: vanGoghWorks.map(w => ({title: w.title, subtitle: w.o
 search_objects({query: "egypt pharaoh", departmentId: 10, hasImages: true})
 
 // 2. Rendu avec metadonnees culturelles
-component("gallery", {images: egyptWorks.map(w => ({src: w.primaryImage, alt: w.title}))})
+component("gallery", {images: egyptWorks.map(w => ({src: w.primaryImageSmall, alt: w.title}))})
 component("table", {columns: ["Titre", "Periode", "Culture", "Medium"], rows: egyptDetails})
 component("kv", {pairs: [["Departement", "Egyptian Art"], ["Source", "Met Museum — Open Access"]]})
 \`\`\`
@@ -116,7 +116,7 @@ component("kv", {pairs: [["Departement", "Egyptian Art"], ["Source", "Met Museum
 
 - **Trop d'appels \`get_object\`** : la recherche retourne parfois des centaines d'IDs — limiter a 5-10 appels detail pour la performance
 - **Oeuvres sans image** : beaucoup d'objets Met n'ont pas de \`primaryImage\` — toujours filtrer avec \`hasImages: true\` dans la recherche ou verifier le champ
-- **Images basse resolution** : utiliser \`primaryImage\` (haute resolution) pour la galerie, \`primaryImageSmall\` pour les cards/thumbnails
+- **Images haute resolution cassees** : utiliser \`primaryImageSmall\` (web-large) pour la galerie et les cards — les URLs \`primaryImage\` (original) retournent souvent des 404
 - **Oublier la licence** : les oeuvres en domaine public (\`isPublicDomain: true\`) peuvent etre affichees librement, les autres ont un champ \`rights\` a respecter
 - **Artiste inconnu** : beaucoup d'oeuvres anciennes n'ont pas d'\`artistDisplayName\` — afficher "Artiste inconnu" ou la culture/periode a la place
 `,
@@ -715,7 +715,7 @@ Etape 2 : pour chaque ID, \`get_object({objectID: id})\` → \`{primaryImage, ti
 \`\`\`
 component("gallery", {
   images: objects.map(obj => ({
-    src: obj.primaryImage,
+    src: obj.primaryImageSmall,
     alt: obj.title + " — " + obj.artistDisplayName,
     caption: obj.objectDate
   }))
@@ -740,7 +740,7 @@ component("gallery", {
 
 ## Erreurs courantes
 
-- **Inventer des URLs placeholder** (\`https://example.com/image.jpg\`) — strictement INTERDIT
+- **Inventer des URLs placeholder** (\`https://example.com/image.jpg\`, \`via.placeholder.com\`, \`placehold.co\`, \`dummyimage.com\`, \`?text=...\`) — strictement INTERDIT. Si aucune image réelle n'est retournée par l'API, ne PAS afficher de galerie.
 - **Oublier de verifier** que le champ image existe dans les donnees retournees (certains objets Met Museum n'ont pas de \`primaryImage\`)
 - **Utiliser \`text\` pour afficher des URLs** au lieu de \`gallery\` — les images doivent etre rendues visuellement
 - **Ne pas adapter la taille** : iNaturalist retourne des thumbnails "square" par defaut, remplacer par "medium" ou "large" dans l'URL

package/src/recipes/afficher-oeuvres-art-collection-musee.md

@@ -46,9 +46,9 @@ Le serveur Met Museum donne acces a la collection du Metropolitan Museum of Art
    ```
    component("gallery", {
      images: objects
-       .filter(o => o.primaryImage)
+       .filter(o => o.primaryImageSmall)
        .map(o => ({
-         src: o.primaryImage,
+         src: o.primaryImageSmall,
          alt: o.title + " — " + o.artistDisplayName,
          caption: o.objectDate + " | " + o.medium
        }))
@@ -94,7 +94,7 @@ objectIDs.slice(0, 8).forEach(id => get_object({objectID: id}))
 
 // 3. Rendu
 component("stat-card", {label: "Oeuvres de Van Gogh", value: "8", icon: "palette"})
-component("gallery", {images: vanGoghWorks.map(w => ({src: w.primaryImage, alt: w.title, caption: w.objectDate}))})
+component("gallery", {images: vanGoghWorks.map(w => ({src: w.primaryImageSmall, alt: w.title, caption: w.objectDate}))})
 component("cards", {items: vanGoghWorks.map(w => ({title: w.title, subtitle: w.objectDate, image: w.primaryImageSmall, body: w.medium}))})
 ```
 
@@ -104,7 +104,7 @@ component("cards", {items: vanGoghWorks.map(w => ({title: w.title, subtitle: w.o
 search_objects({query: "egypt pharaoh", departmentId: 10, hasImages: true})
 
 // 2. Rendu avec metadonnees culturelles
-component("gallery", {images: egyptWorks.map(w => ({src: w.primaryImage, alt: w.title}))})
+component("gallery", {images: egyptWorks.map(w => ({src: w.primaryImageSmall, alt: w.title}))})
 component("table", {columns: ["Titre", "Periode", "Culture", "Medium"], rows: egyptDetails})
 component("kv", {pairs: [["Departement", "Egyptian Art"], ["Source", "Met Museum — Open Access"]]})
 ```
@@ -113,6 +113,6 @@ component("kv", {pairs: [["Departement", "Egyptian Art"], ["Source", "Met Museum
 
 - **Trop d'appels `get_object`** : la recherche retourne parfois des centaines d'IDs — limiter a 5-10 appels detail pour la performance
 - **Oeuvres sans image** : beaucoup d'objets Met n'ont pas de `primaryImage` — toujours filtrer avec `hasImages: true` dans la recherche ou verifier le champ
-- **Images basse resolution** : utiliser `primaryImage` (haute resolution) pour la galerie, `primaryImageSmall` pour les cards/thumbnails
+- **Images haute resolution cassees** : utiliser `primaryImageSmall` (web-large) pour la galerie et les cards — les URLs `primaryImage` (original) retournent souvent des 404
 - **Oublier la licence** : les oeuvres en domaine public (`isPublicDomain: true`) peuvent etre affichees librement, les autres ont un champ `rights` a respecter
 - **Artiste inconnu** : beaucoup d'oeuvres anciennes n'ont pas d'`artistDisplayName` — afficher "Artiste inconnu" ou la culture/periode a la place

package/src/recipes/gallery-images.md

@@ -55,7 +55,7 @@ Etape 2 : pour chaque ID, `get_object({objectID: id})` → `{primaryImage, title
 ```
 component("gallery", {
   images: objects.map(obj => ({
-    src: obj.primaryImage,
+    src: obj.primaryImageSmall,
     alt: obj.title + " — " + obj.artistDisplayName,
     caption: obj.objectDate
   }))
@@ -80,7 +80,7 @@ component("gallery", {
 
 ## Erreurs courantes
 
-- **Inventer des URLs placeholder** (`https://example.com/image.jpg`) — strictement INTERDIT
+- **Inventer des URLs placeholder** (`https://example.com/image.jpg`, `via.placeholder.com`, `placehold.co`, `dummyimage.com`, `?text=...`) — strictement INTERDIT. Si aucune image réelle n'est retournée par l'API, ne PAS afficher de galerie.
 - **Oublier de verifier** que le champ image existe dans les donnees retournees (certains objets Met Museum n'ont pas de `primaryImage`)
 - **Utiliser `text` pour afficher des URLs** au lieu de `gallery` — les images doivent etre rendues visuellement
 - **Ne pas adapter la taille** : iNaturalist retourne des thumbnails "square" par defaut, remplacer par "medium" ou "large" dans l'URL

package/src/recipes/widgets/cards.md

@@ -36,5 +36,6 @@ Pour afficher une collection d'éléments riches — produits, articles, projets
 2. Appeler `autoui_webmcp_widget_display('cards', { title: 'Projets actifs', cards: [{ title: 'Refonte UI', description: 'Migration vers Svelte 5', subtitle: 'Q2 2024', tags: ['frontend', 'priorité haute'] }] })`
 
 ## Erreurs courantes
-- Ne JAMAIS inventer d'URLs d'images pour le champ `image`. Utiliser UNIQUEMENT les URLs retournées par les outils MCP (query_sql, search_recipes, etc.). Si aucune URL n'est disponible, ne pas inclure de champ image.
+- Ne JAMAIS inventer d'URLs d'images pour le champ `image`. Utiliser UNIQUEMENT les URLs retournées par les outils MCP. Si aucune URL n'est disponible, ne pas inclure de champ image — le widget s'affiche correctement sans.
+- STRICTEMENT INTERDIT : URLs placeholder (`via.placeholder.com`, `placehold.co`, `dummyimage.com`, `?text=...`). Omettre le champ `image` plutôt que de mettre un placeholder.
 - Toujours fournir un `title` pour chaque carte

package/src/recipes/widgets/gallery.md

@@ -35,4 +35,5 @@ Pour afficher une collection d'images en grille — galerie photo, résultats de
 
 ## Erreurs courantes
 - Ne JAMAIS fabriquer d'URLs d'images — utiliser uniquement celles retournées par les outils MCP
+- STRICTEMENT INTERDIT : URLs placeholder (`via.placeholder.com`, `placehold.co`, `dummyimage.com`, `?text=...`, `example.com/image.jpg`). Si aucune image réelle n'est disponible, ne PAS afficher de galerie — utiliser un widget `text` ou `cards` sans image à la place
 - Toujours fournir un `alt` pour l'accessibilité

package/src/token-tracker.ts

@@ -51,6 +51,7 @@ export class TokenTracker {
   record(
     usage: { input_tokens: number; output_tokens: number; cache_read_input_tokens?: number },
     latencyMs?: number,
+    isWasm = false,
   ): void {
     const now = Date.now();
     const event: TokenEvent = {
@@ -71,7 +72,7 @@ export class TokenTracker {
     this._metrics.lastCacheReadTokens = event.cacheRead;
     this._metrics.lastLatencyMs = latencyMs ?? 0;
     this._metrics.totalCachedGB = this._metrics.totalCacheReadTokens * 4 / 1e9;
-    this._metrics.isWasm = false;
+    this._metrics.isWasm = isWasm;
 
     // Rolling per-minute rates
     const oneMinAgo = now - 60_000;

package/src/tool-layers.ts

@@ -6,6 +6,7 @@ import type { WebMcpToolDef } from '@webmcp-auto-ui/core';
 import { sanitizeSchema, sanitizeSchemaWithReport, flattenSchema } from '@webmcp-auto-ui/core';
 import type { SchemaPatch } from '@webmcp-auto-ui/core';
 import { DiscoveryCache, type ServerCache } from './discovery-cache.js';
+import type { PipelineTrace } from './pipeline-trace.js';
 
 /** Sanitize a server name for use in tool name prefixes.
  *  Returns a clean underscore-separated identifier with no "mcp"/"server" noise.
@@ -54,9 +55,20 @@ export interface SchemaTransformOptions {
   onSchemaPatch?: (toolName: string, patches: SchemaPatch[]) => void;
 }
 
-/** Path maps for flattened schemas — keyed by prefixed tool name */
+/**
+ * @deprecated Use the `pathMaps` field returned by `buildToolsFromLayers()` instead.
+ * This singleton is NOT parallel-safe — concurrent agent loops will clobber each other.
+ * Kept for backward compatibility only; populated as a side-effect of `buildToolsFromLayers`.
+ */
 export const flattenPathMaps = new Map<string, Record<string, string[]>>();
 
+/** Result of buildToolsFromLayers — tools + per-call path maps (parallel-safe) */
+export interface BuildToolsResult {
+  tools: ProviderTool[];
+  /** Path maps for flattened schemas, keyed by prefixed tool name. Empty if flatten is off. */
+  pathMaps: Map<string, Record<string, string[]>>;
+}
+
 // ── Canonical tool resolution (4-layer matching) ─────────────────────
 //
 // MCP servers expose tools with arbitrary names. We need to identify which
@@ -189,7 +201,7 @@ function isStrictCompatible(schema: Record<string, unknown>): boolean {
 }
 
 /** Convert McpToolDef[] to ProviderTool[] */
-export function toProviderTools(tools: McpToolDef[], schemaOptions?: SchemaTransformOptions): ProviderTool[] {
+export function toProviderTools(tools: McpToolDef[], schemaOptions?: SchemaTransformOptions, trace?: PipelineTrace): ProviderTool[] {
   return tools.map(t => {
     let schema = (t.inputSchema ?? { type: 'object', properties: {}, additionalProperties: false }) as import('@webmcp-auto-ui/core').JsonSchema;
     if (schemaOptions?.sanitize !== false) {
@@ -197,6 +209,14 @@ export function toProviderTools(tools: McpToolDef[], schemaOptions?: SchemaTrans
       schema = report.schema;
       if (report.patches.length > 0) {
         schemaOptions?.onSchemaPatch?.(t.name, report.patches);
+        if (trace) {
+          for (const p of report.patches) {
+            const msg = p.type === 'additionalProperties'
+              ? `added additionalProperties:false at ${p.path}`
+              : `removed ${p.keyword} at ${p.path}`;
+            trace.push('sanitize', t.name, msg, 'warn');
+          }
+        }
       }
     }
     const schemaObj = schema as Record<string, unknown>;
@@ -214,14 +234,22 @@ export function toProviderTools(tools: McpToolDef[], schemaOptions?: SchemaTrans
 }
 
 /** Convert WebMcpToolDef[] to ProviderTool[] (Fix 12: sanitize schemas) */
-function webmcpToProviderTools(tools: WebMcpToolDef[], schemaOptions?: SchemaTransformOptions): ProviderTool[] {
+function webmcpToProviderTools(tools: WebMcpToolDef[], schemaOptions?: SchemaTransformOptions, trace?: PipelineTrace): ProviderTool[] {
   return tools.map(t => {
-    let schema = (t.inputSchema ?? { type: 'object', properties: {} }) as import('@webmcp-auto-ui/core').JsonSchema;
+    let schema = (t.inputSchema ?? { type: 'object', properties: {}, additionalProperties: false }) as import('@webmcp-auto-ui/core').JsonSchema;
     if (schemaOptions?.sanitize !== false) {
       const report = sanitizeSchemaWithReport(schema);
       schema = report.schema;
       if (report.patches.length > 0) {
         schemaOptions?.onSchemaPatch?.(t.name, report.patches);
+        if (trace) {
+          for (const p of report.patches) {
+            const msg = p.type === 'additionalProperties'
+              ? `added additionalProperties:false at ${p.path}`
+              : `removed ${p.keyword} at ${p.path}`;
+            trace.push('sanitize', t.name, msg, 'warn');
+          }
+        }
       }
     }
     const schemaObj = schema as Record<string, unknown>;
@@ -236,19 +264,20 @@ function webmcpToProviderTools(tools: WebMcpToolDef[], schemaOptions?: SchemaTra
 
 /** Build ProviderTool[] from structured layers.
  *  ALL tools are prefixed: {serverName}_{protocol}_{toolName}
+ *  Returns { tools, pathMaps } — use pathMaps instead of the deprecated flattenPathMaps singleton.
  */
-export function buildToolsFromLayers(layers: ToolLayer[], schemaOptions?: SchemaTransformOptions): ProviderTool[] {
+export function buildToolsFromLayers(layers: ToolLayer[], schemaOptions?: SchemaTransformOptions, trace?: PipelineTrace): BuildToolsResult {
   const tools: ProviderTool[] = [];
 
   for (const layer of layers) {
     const prefix = `${sanitizeServerName(layer.serverName)}_${layer.protocol}_`;
 
     if (layer.protocol === 'mcp') {
-      for (const tool of toProviderTools(layer.tools, schemaOptions)) {
+      for (const tool of toProviderTools(layer.tools, schemaOptions, trace)) {
         tools.push({ ...tool, name: `${prefix}${tool.name}` });
       }
     } else {
-      for (const tool of webmcpToProviderTools(layer.tools, schemaOptions)) {
+      for (const tool of webmcpToProviderTools(layer.tools, schemaOptions, trace)) {
         tools.push({ ...tool, name: `${prefix}${tool.name}` });
       }
     }
@@ -260,21 +289,34 @@ export function buildToolsFromLayers(layers: ToolLayer[], schemaOptions?: Schema
     seen.set(tool.name, tool);
   }
 
+  const localPathMaps = new Map<string, Record<string, string[]>>();
+
   // Apply flatten if requested
   if (schemaOptions?.flatten) {
-    flattenPathMaps.clear();
     const result = Array.from(seen.values());
     for (const tool of result) {
       const { schema: flatSchema, pathMap } = flattenSchema(tool.input_schema as import('@webmcp-auto-ui/core').JsonSchema);
       if (Object.keys(pathMap).length > 0) {
         tool.input_schema = flatSchema as Record<string, unknown>;
-        flattenPathMaps.set(tool.name, pathMap);
+        localPathMaps.set(tool.name, pathMap);
+      }
+      if (trace) {
+        const flattenedCount = Object.keys(pathMap).filter(k => pathMap[k].length > 1).length;
+        const totalProps = Object.keys((tool.input_schema as Record<string, unknown>).properties ?? {}).length;
+        if (flattenedCount === 0 && totalProps > 0) {
+          trace.push('flatten', tool.name, `0/${totalProps} properties flattened`, 'warn');
+        }
       }
     }
-    return result;
+
+    // Populate deprecated singleton for backward compat
+    flattenPathMaps.clear();
+    for (const [k, v] of localPathMaps) flattenPathMaps.set(k, v);
+
+    return { tools: result, pathMaps: localPathMaps };
   }
 
-  return Array.from(seen.values());
+  return { tools: Array.from(seen.values()), pathMaps: localPathMaps };
 }
 
 /** Result of buildSystemPromptWithAliases — prompt text + per-call alias map */
@@ -347,42 +389,44 @@ export function buildSystemPromptWithAliases(layers: ToolLayer[]): SystemPromptR
     }
   }
 
-  // ── Build prompt (cascade: search recipes → list recipes → search tools → list tools) ──
-  let prompt = `Tu es un assistant IA qui aide les utilisateurs en répondant à leurs questions et en accomplissant des tâches à l'aide de recettes. Tu NE DOIS PAS sauter d'étapes.
+  // ── Build prompt (cascade: list recipes → search recipes → list tools → search tools) ──
+  let prompt = `Tu es un assistant IA qui aide les utilisateurs en répondant à leurs questions et en accomplissant des tâches à l'aide de recettes (appelées aussi skills ou recipes). Ces recettes ne sont pas des recettes de cuisine mais des instructions pour un agent IA avec des scripts, des schémas et des informations pour l'aider. Si tu ne trouve pas de recette ou d'outils appropriés, tu peux fallback sur un chat traditionnel sans tool calling (ETAPE 5).
+
+Tu NE DOIS PAS sauter d'étapes.
 
 RÈGLE CRITIQUE : Tu DOIS exécuter toutes les étapes en silence. Ne génère AUCUNE réflexion interne, raisonnement ou texte intermédiaire.
 
-ÉTAPE 1 — Recherche de recette
+ÉTAPE 1 — Liste toutes les recettes
 
-Cherche une recette pertinente avec un mot-clé extrait de la demande :
+Cherche une recette pertinente parmi celles-ci :
 
-${searchRecipes.join('\n')}
+${listRecipes.join('\n')}
 
 Si au moins une recette pertinente est trouvée → passe à l'ÉTAPE 2.
 Si aucun résultat → passe à l'ÉTAPE 1b.
 
-ÉTAPE 1b — Liste des recettes
+ÉTAPE 1b — Recherche de recettes
 
-Aucune recette trouvée par recherche. Liste toutes les recettes disponibles :
+Aucune recette trouvée par liste. Recherche avec un ou des mot-clé(s) extrait de la demande :
 
-${listRecipes.join('\n')}
+${searchRecipes.join('\n')}
 
 Choisis la recette la plus pertinente par rapport à la demande.
 Si une recette correspond → passe à l'ÉTAPE 2.
 Si aucune recette disponible ou pertinente → passe à l'ÉTAPE 1c.
 
-ÉTAPE 1c — Recherche d'outils
+ÉTAPE 1c — Liste des outils
 
-Aucune recette applicable. Cherche un outil pertinent :
+Aucune recette applicable. Liste un outil pertinent :
 
-${searchTools.join('\n')}
+${listTools.join('\n')}
 
 Si un outil pertinent est trouvé → utilise-le directement pour répondre (passe à l'ÉTAPE 3).
 Si aucun résultat → passe à l'ÉTAPE 1d.
 
-ÉTAPE 1d — Liste des outils
+ÉTAPE 1d — Recherche d'outils
 
-${listTools.join('\n')}
+${searchTools.join('\n')}
 
 Choisis le ou les outils les plus pertinents et utilise-les pour répondre (passe à l'ÉTAPE 3).
 
@@ -394,26 +438,17 @@ Lis les instructions complètes de la recette sélectionnée.
 
 ÉTAPE 3 — Exécution
 
-Suis les instructions de la recette exactement si tu en as une. Sinon utilise les outils directement. Produis UNIQUEMENT le résultat final : un résumé en une phrase de l'action effectuée, ainsi que le résultat.
+Suis les instructions de la recette exactement si tu en as une. Sinon utilise les outils directement. Produis UNIQUEMENT le résultat final, un résumé en une phrase de l'action effectuée, ainsi que le résultat.
 
 ÉTAPE 4 — Affichage UI
 
-Sauf indication contraire d'une recette, utilise ces outils :
+Sauf indication UI contraire d'une recette, utilise ces outils pour afficher tes réponses sur le canvas :
 
 ${actionTools.join('\n')}
 
-GESTION DES ERREURS D'OUTILS (RÈGLE PRIORITAIRE)
+ÉTAPE 5 — Fallback
 
-Si un outil retourne une erreur (validation, schéma, type, paramètres invalides ou rejet explicite), tu DOIS d'abord traiter cette erreur avant toute autre action.
-
-1. Analyse uniquement le message d'erreur et le schéma attendu.
-2. Corrige l'appel en respectant STRICTEMENT le schéma (pas de champs supplémentaires, types respectés).
-3. Si une valeur est mal formée (ex: JSON sérialisé en string), convertis-la sans changer le contenu métier.
-4. Tu n'as PAS le droit d'inventer de nouveaux formats, champs ou structures.
-5. Ne change PAS de recette ou de widget tant que l'appel n'a pas été retenté au moins une fois.
-6. Après deux échecs consécutifs identiques, tu peux chercher une autre recette.
-
-Ne fabrique jamais d'URLs d'images — utilise uniquement celles retournées par les outils.`;
+En cas d'échec des étapes précédentes, fallback sur un chat classique sans tool calling.`;
 
   return { prompt, aliasMap };
 }
@@ -442,7 +477,7 @@ export interface DiscoveryToolsResult {
  * Build discovery-only tools with a local alias map (parallel-safe).
  * Prefer this over buildDiscoveryTools() when running multiple agent loops.
  */
-export function buildDiscoveryToolsWithAliases(layers: ToolLayer[], schemaOptions?: SchemaTransformOptions): DiscoveryToolsResult {
+export function buildDiscoveryToolsWithAliases(layers: ToolLayer[], schemaOptions?: SchemaTransformOptions, trace?: PipelineTrace): DiscoveryToolsResult {
   const tools: ProviderTool[] = [];
   const aliasMap = new Map<string, string>();
 
@@ -450,7 +485,7 @@ export function buildDiscoveryToolsWithAliases(layers: ToolLayer[], schemaOption
     const prefix = `${sanitizeServerName(layer.serverName)}_${layer.protocol}_`;
 
     if (layer.protocol === 'mcp') {
-      const allProviderTools = toProviderTools(layer.tools, schemaOptions);
+      const allProviderTools = toProviderTools(layer.tools, schemaOptions, trace);
       const matches = resolveCanonicalTools(layer.tools);
 
       for (const m of matches) {
@@ -481,7 +516,7 @@ export function buildDiscoveryToolsWithAliases(layers: ToolLayer[], schemaOption
       });
     } else {
       // WebMCP: search_recipes, list_recipes, get_recipe, plus action tools (widget_display, canvas, recall)
-      for (const tool of webmcpToProviderTools(layer.tools, schemaOptions)) {
+      for (const tool of webmcpToProviderTools(layer.tools, schemaOptions, trace)) {
         if (tool.name === 'search_recipes' || tool.name === 'list_recipes' || tool.name === 'get_recipe' ||
             tool.name === 'widget_display' || tool.name === 'canvas' || tool.name === 'recall') {
           tools.push({ ...tool, name: `${prefix}${tool.name}` });
@@ -532,14 +567,15 @@ export function activateServerTools(
   currentTools: ProviderTool[],
   layer: ToolLayer,
   schemaOptions?: SchemaTransformOptions,
+  trace?: PipelineTrace,
 ): ProviderTool[] {
   const prefix = `${sanitizeServerName(layer.serverName)}_${layer.protocol}_`;
   const existing = new Set(currentTools.map(t => t.name));
   const newTools = [...currentTools];
 
   const layerTools = layer.protocol === 'mcp'
-    ? toProviderTools(layer.tools, schemaOptions)
-    : webmcpToProviderTools(layer.tools, schemaOptions);
+    ? toProviderTools(layer.tools, schemaOptions, trace)
+    : webmcpToProviderTools(layer.tools, schemaOptions, trace);
 
   for (const tool of layerTools) {
     const prefixed = `${prefix}${tool.name}`;
@@ -559,6 +595,10 @@ export function buildDiscoveryCache(layers: ToolLayer[]): DiscoveryCache {
   const cache = new DiscoveryCache();
 
   for (const layer of layers) {
+    // Skip WebMCP layers — their discovery tools (list_recipes, etc.) are local
+    // closures over the widgets Map and must be executed directly, not cached.
+    if (layer.protocol === 'webmcp') continue;
+
     const prefix = sanitizeServerName(layer.serverName);
     const serverCache: ServerCache = {
       recipes: [],

package/src/types.ts

@@ -93,11 +93,14 @@ export interface AgentCallbacks {
   onLLMRequest?: (messages: ChatMessage[], tools: ProviderTool[]) => void;
   onLLMResponse?: (response: LLMResponse, latencyMs: number, tokens?: { input: number; output: number }) => void;
   onToolCall?: (call: ToolCall) => void;
-  /** Called when a widget_display renders a widget. Return { id } so the LLM knows the block id. */
-  onWidget?: (type: string, data: Record<string, unknown>) => { id: string } | void;
+  /** Called when a widget_display renders a widget. Return { id } so the LLM knows the block id.
+   * @param serverName - the WebMCP server that produced the widget (e.g. "chartjs", "d3") */
+  onWidget?: (type: string, data: Record<string, unknown>, serverName?: string) => { id: string } | void;
   onClear?: () => void;
   onText?: (text: string) => void;
   onToken?: (token: string) => void;
+  /** Called for pipeline trace / auto-repair / nano-rag diagnostics (not streamed to UI) */
+  onTrace?: (message: string) => void;
   onDone?: (metrics: AgentMetrics) => void;
   // Canvas mutation tools
   onUpdate?: (id: string, data: Record<string, unknown>) => void;