@webmcp-auto-ui/agent 2.5.25 → 2.5.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmcp-auto-ui/agent",
-  "version": "2.5.25",
+  "version": "2.5.27",
   "description": "LLM agent loop + remote/WASM/local providers + MCP wrapper",
   "license": "AGPL-3.0-or-later",
   "type": "module",

package/src/autoui-server.ts

@@ -3,6 +3,23 @@
 // ---------------------------------------------------------------------------
 
 import { createWebMcpServer, parseFrontmatter } from '@webmcp-auto-ui/core';
+import { RAW_RECIPES } from './recipes/_generated.js';
+
+// Notebook widget recipes (vanilla renderers)
+// @ts-ignore — Vite raw imports, not resolved by tsc
+import compactRecipe from './notebook-widgets/recipes/compact.md?raw';
+// @ts-ignore
+import workspaceRecipe from './notebook-widgets/recipes/workspace.md?raw';
+// @ts-ignore
+import documentRecipe from './notebook-widgets/recipes/document.md?raw';
+// @ts-ignore
+import editorialRecipe from './notebook-widgets/recipes/editorial.md?raw';
+
+// Notebook widget renderers (vanilla JS)
+import { render as renderCompact } from './notebook-widgets/compact.js';
+import { render as renderWorkspace } from './notebook-widgets/workspace.js';
+import { render as renderDocument } from './notebook-widgets/document.js';
+import { render as renderEditorial } from './notebook-widgets/editorial.js';
 
 // ---------------------------------------------------------------------------
 // Inline recipes (frontmatter + body)
@@ -1007,6 +1024,33 @@ for (const recipe of RECIPES) {
   autoui.registerWidget(recipe, undefined);
 }
 
+// Notebook widgets — vanilla renderers (resolved via WidgetRenderer vanilla path)
+const NOTEBOOK_WIDGETS: Array<[string, (container: HTMLElement, data: any) => any]> = [
+  [compactRecipe as string, renderCompact],
+  [workspaceRecipe as string, renderWorkspace],
+  [documentRecipe as string, renderDocument],
+  [editorialRecipe as string, renderEditorial],
+];
+for (const [recipe, renderer] of NOTEBOOK_WIDGETS) {
+  autoui.registerWidget(recipe, renderer as any);
+}
+
+// Register flow recipes (multi-step procedures) from the global recipe registry
+// that declare this server (autoui) in their frontmatter.
+for (const [key, rawMd] of Object.entries(RAW_RECIPES)) {
+  const { frontmatter } = parseFrontmatter(rawMd);
+  const servers = (Array.isArray(frontmatter.servers) ? frontmatter.servers : []) as string[];
+  if (servers.map((s) => s.toLowerCase()).includes('autoui')) {
+    try {
+      autoui.registerRecipe(rawMd);
+    } catch (e) {
+      // Skip malformed recipes (missing id/name) — log for debugging
+      // eslint-disable-next-line no-console
+      console.warn(`[autoui] Failed to register flow recipe "${key}":`, e);
+    }
+  }
+}
+
 // Expose recipe summaries to the UI browser
 const parsedRecipes = RECIPES.map((md) => {
   const { frontmatter, body } = parseFrontmatter(md);

package/src/diagnostics.ts

@@ -2,7 +2,7 @@
 
 import type { ToolLayer } from './tool-layers.js';
 import type { ProviderTool } from './types.js';
-import { sanitizeServerName } from './tool-layers.js';
+import { sanitizeServerName, protocolToken } from './tool-layers.js';
 import { sanitizeSchemaWithReport } from '@webmcp-auto-ui/core';
 import type { JsonSchema, SchemaPatch } from '@webmcp-auto-ui/core';
 
@@ -41,8 +41,8 @@ export function runDiagnostics(
       diagnostics.push({
         severity: 'error',
         title: `Bruit dans le prefixe "${prefix}"`,
-        detail: `Le serveur "${layer.serverName}" produit un prefixe contenant "${noise.join(', ')}". Les outils auront des noms ambigus comme ${prefix}_mcp_list_recipes.`,
-        quickFix: `Ajoutez au system prompt:\n"Note: le serveur ${layer.serverName} utilise le prefixe '${prefix}'. Utilisez ${prefix}_mcp_<tool> ou ${prefix}_webmcp_<tool>."`,
+        detail: `Le serveur "${layer.serverName}" produit un prefixe contenant "${noise.join(', ')}". Les outils auront des noms ambigus comme ${prefix}_data_list_recipes.`,
+        quickFix: `Ajoutez au system prompt:\n"Note: le serveur ${layer.serverName} utilise le prefixe '${prefix}'. Utilisez ${prefix}_data_<tool> ou ${prefix}_ui_<tool>."`,
         codeFix: `Renommer le serveur MCP cote serveur pour ne pas inclure "mcp"/"server" dans le nom.`,
       });
     }
@@ -88,14 +88,14 @@ export function runDiagnostics(
   // Include discovery tools (search_tools, list_tools) which are generated dynamically
   const toolNames = new Set(tools.map(t => t.name));
   for (const layer of layers) {
-    const prefix = `${sanitizeServerName(layer.serverName)}_${layer.protocol}_`;
+    const prefix = `${sanitizeServerName(layer.serverName)}_${protocolToken(layer.protocol)}_`;
     toolNames.add(`${prefix}search_tools`);
     toolNames.add(`${prefix}list_tools`);
     toolNames.add(`${prefix}search_recipes`);
     toolNames.add(`${prefix}list_recipes`);
     toolNames.add(`${prefix}get_recipe`);
   }
-  const toolPattern = /\b([a-z][a-z0-9_]{2,})_(mcp|webmcp)_([a-z][a-z0-9_]+)\b/g;
+  const toolPattern = /\b([a-z][a-z0-9_]{2,})_(data|ui)_([a-z][a-z0-9_]+)\b/g;
   let match;
   while ((match = toolPattern.exec(systemPrompt)) !== null) {
     const fullName = match[0];
@@ -112,7 +112,7 @@ export function runDiagnostics(
   // 5. Strict mode — schemas that were auto-patched
   // Must run on raw (pre-sanitize) schemas; sanitized tools will never show patches.
   // Skipped for Gemma — it doesn't use additionalProperties/strict mode at all.
-  if (!skipSchemaChecks) {
+  if (!skipSchemaChecks && schemaOptions?.strict) {
     const checkTools = rawTools ?? tools;
     for (const tool of checkTools) {
       const { patches } = sanitizeSchemaWithReport(tool.input_schema as JsonSchema);

package/src/discovery-cache.ts

@@ -5,6 +5,7 @@
  */
 
 import type { ProviderTool } from './types.js';
+import type { PipelineTrace } from './pipeline-trace.js';
 
 /** Tool names that are resolved locally from cache — hidden from user-facing browsers. */
 export const DISCOVERY_TOOL_NAMES = new Set(['list_recipes', 'search_recipes', 'get_recipe', 'list_tools', 'search_tools']);
@@ -100,13 +101,18 @@ export class DiscoveryCache {
     serverPrefix: string,
     realToolName: string,
     params: Record<string, unknown>,
+    trace?: PipelineTrace,
   ): string | null {
     const cache = this.servers.get(serverPrefix);
     if (!cache) return null;
 
     switch (realToolName) {
       case 'search_recipes': {
-        const query = ((params.query ?? '') as string).toLowerCase();
+        const rawQuery = params.query ?? params.q ?? params.keyword ?? params.search;
+        const query = String(rawQuery ?? '').toLowerCase();
+        if (rawQuery === undefined && Object.keys(params).length > 0) {
+          trace?.push('discovery', realToolName, `unknown param keys: ${Object.keys(params).join(',')} — expected query/q/keyword/search`, 'warn');
+        }
         const results = query
           ? cache.recipes.filter(r =>
               r.name.toLowerCase().includes(query) ||
@@ -121,7 +127,11 @@ export class DiscoveryCache {
       }
 
       case 'get_recipe': {
-        const key = String(params.name ?? params.id ?? '').toLowerCase();
+        const rawKey = params.name ?? params.id ?? params.recipe_id ?? params.key;
+        const key = String(rawKey ?? '').toLowerCase();
+        if (rawKey === undefined && Object.keys(params).length > 0) {
+          trace?.push('discovery', realToolName, `unknown param keys: ${Object.keys(params).join(',')} — expected name/id/recipe_id/key`, 'warn');
+        }
         const recipe = cache.recipes.find(r =>
           (r.name?.toLowerCase() === key) ||
           ((r as Record<string, unknown>).id as string | undefined)?.toLowerCase() === key
@@ -131,7 +141,11 @@ export class DiscoveryCache {
       }
 
       case 'search_tools': {
-        const query = ((params.query ?? '') as string).toLowerCase();
+        const rawQuery = params.query ?? params.q ?? params.keyword ?? params.search;
+        const query = String(rawQuery ?? '').toLowerCase();
+        if (rawQuery === undefined && Object.keys(params).length > 0) {
+          trace?.push('discovery', realToolName, `unknown param keys: ${Object.keys(params).join(',')} — expected query/q/keyword/search`, 'warn');
+        }
         const results = query
           ? cache.tools.filter(t =>
               t.name.toLowerCase().includes(query) ||

package/src/index.ts

@@ -5,6 +5,16 @@ export { RemoteLLMProvider } from './providers/remote.js';
 export type { RemoteLLMProviderOptions } from './providers/remote.js';
 export { WasmProvider } from './providers/wasm.js';
 export type { WasmProviderOptions, WasmStatus } from './providers/wasm.js';
+export { TransformersProvider } from './providers/transformers.js';
+export type { TransformersProviderOptions, TransformersStatus } from './providers/transformers.js';
+export { TRANSFORMERS_MODELS, getTransformersModel, listTransformersModels } from './providers/transformers-models.js';
+export type { TransformersModelEntry, TransformersFamily, ToolCallFormat } from './providers/transformers-models.js';
+export { parseToolCalls } from './prompts/tool-call-parsers.js';
+export type { ParseResult } from './prompts/tool-call-parsers.js';
+export { loadOrDownloadModel, clearModelCache } from './util/opfs-cache.js';
+export type { ModelFileSpec, CacheProgress } from './util/opfs-cache.js';
+export { buildGemmaPrompt } from './prompts/index.js';
+export type { BuildGemmaPromptInput } from './prompts/index.js';
 export { LocalLLMProvider } from './providers/local.js';
 export type { LocalLLMProviderOptions, LocalBackend } from './providers/local.js';
 export { createProvider } from './providers/factory.js';
@@ -18,15 +28,16 @@ export type { GemmaProviderOptions, GemmaStatus } from './providers/gemma.js';
 
 // Agent loop
 export { runAgentLoop, toProviderTools, fromMcpTools, trimConversationHistory } from './loop.js';
-export { buildSystemPrompt } from './tool-layers.js';
+export { buildSystemPrompt, buildSystemPromptWithAliases } from './prompts/index.js';
+export type { SystemPromptResult } from './prompts/index.js';
 export type { AgentLoopOptions } from './loop.js';
 
 // autoui — built-in WebMCP server
 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, BuildToolsResult } from './tool-layers.js';
+export { buildToolsFromLayers, buildDiscoveryTools, buildDiscoveryToolsWithAliases, activateServerTools, resolveCanonicalTools, toolAliasMap, flattenPathMaps, buildDiscoveryCache } from './tool-layers.js';
+export type { ToolLayer, McpLayer, WebMcpLayer, DiscoveryToolsResult, SchemaTransformOptions, BuildToolsResult, ProviderKind } from './tool-layers.js';
 
 // Discovery cache
 export { DiscoveryCache, DISCOVERY_TOOL_NAMES } from './discovery-cache.js';
@@ -63,12 +74,15 @@ export type { RepairResult } from './auto-repair.js';
 // Pipeline trace
 export { PipelineTrace, type TraceEntry } from './pipeline-trace.js';
 
+// Trace observer — live visual trace for runAgentLoop
+export { createTraceObserver, type TraceObserver, type TraceObserverContext, type RoundTripDetail } from './trace-observer.js';
+
 // Nano-RAG — context compaction
 export { ContextRAG, type ContextRAGOptions } from './nano-rag/mod.js';
 
 // Types
 export type {
-  RemoteModelId, WasmModelId, LLMId, ModelId,
+  RemoteModelId, WasmModelId, TransformersModelId, LLMId, ModelId,
   ChatMessage, ContentBlock, McpToolDef, ProviderTool,
   LLMProvider, LLMResponse, ToolCall, AgentMetrics, AgentResult, AgentCallbacks,
   Recipe, McpRecipe,

package/src/loop.ts

@@ -9,7 +9,8 @@ import type {
   LLMProvider, ProviderTool, McpToolDef, AgentCallbacks,
 } from './types.js';
 import type { ToolLayer, SchemaTransformOptions } from './tool-layers.js';
-import { buildToolsFromLayers, buildSystemPromptWithAliases, buildDiscoveryToolsWithAliases, buildSystemPrompt, activateServerTools, toProviderTools, sanitizeServerName, flattenPathMaps } from './tool-layers.js';
+import { buildToolsFromLayers, buildDiscoveryToolsWithAliases, activateServerTools, toProviderTools, sanitizeServerName, flattenPathMaps } from './tool-layers.js';
+import { buildSystemPromptWithAliases, buildSystemPrompt } from './prompts/index.js';
 import type { DiscoveryCache } from './discovery-cache.js';
 import { unflattenParams, validateJsonSchema } from '@webmcp-auto-ui/core';
 import type { JsonSchema } from '@webmcp-auto-ui/core';
@@ -17,7 +18,7 @@ import { autoRepairParams } from './auto-repair.js';
 import { PipelineTrace } from './pipeline-trace.js';
 
 // Re-export buildSystemPrompt for backward compat
-export { buildSystemPrompt } from './tool-layers.js';
+export { buildSystemPrompt } from './prompts/index.js';
 
 const MAX_RESULT_LEN = 10_000;
 
@@ -28,11 +29,18 @@ const DISCOVERY_TOOL_NAMES = new Set([
 ]);
 
 function isDiscoveryTool(prefixedName: string): boolean {
-  const match = prefixedName.match(/^.+?_(mcp|webmcp)_(.+)$/);
+  const match = prefixedName.match(/^.+?_(data|ui)_(.+)$/);
   if (!match) return false;
   return DISCOVERY_TOOL_NAMES.has(match[2]);
 }
 
+/** Map a tool-name token (data/ui) back to its protocol discriminator (mcp/webmcp). */
+function tokenToProtocol(token: string): 'mcp' | 'webmcp' | null {
+  if (token === 'data') return 'mcp';
+  if (token === 'ui') return 'webmcp';
+  return null;
+}
+
 /**
  * Compress old tool_result blocks in conversation history.
  * IMPORTANT: mutates messages in-place intentionally to reduce memory usage.
@@ -91,9 +99,6 @@ export interface AgentLoopOptions {
   layers?: ToolLayer[];
   maxIterations?: number;
   maxTokens?: number;
-  maxTools?: number;
-  /** WASM-only: cap on conversation messages sent to the model. Default: derived from contextSize. */
-  maxMessages?: number;
   temperature?: number;
   topK?: number;
   cacheEnabled?: boolean;
@@ -118,7 +123,7 @@ export interface AgentLoopOptions {
 }
 
 export async function runAgentLoop(
-  userMessage: string,
+  userMessage: string | ContentBlock[],
   options: AgentLoopOptions
 ): Promise<AgentResult> {
   const {
@@ -126,8 +131,6 @@ export async function runAgentLoop(
     provider,
     maxIterations = 5,
     maxTokens,
-    maxTools,
-    maxMessages,
     temperature,
     topK,
     cacheEnabled = true,
@@ -182,14 +185,14 @@ export async function runAgentLoop(
   if (options.systemPrompt) {
     baseSystemPrompt = options.systemPrompt;
   } else {
-    const sp = buildSystemPromptWithAliases(options.layers ?? []);
+    const sp = buildSystemPromptWithAliases(options.layers ?? [], {
+      providerKind: provider.promptKind ?? 'generic',
+    });
     baseSystemPrompt = sp.prompt;
     for (const [k, v] of sp.aliasMap) localAliasMap.set(k, v);
   }
 
-  const systemPrompt = maxTokens
-    ? `${baseSystemPrompt}\n\nIMPORTANT: Limit your responses to ${maxTokens} tokens.`
-    : baseSystemPrompt;
+  const systemPrompt = baseSystemPrompt;
 
   const messages: ChatMessage[] = [
     ...initialMessages.map(m => ({
@@ -207,7 +210,6 @@ export async function runAgentLoop(
   const allToolCalls: ToolCall[] = [];
   let lastText = '';
   let finishedNormally = false;
-  let discoveryPhase = false;
   let iterationsWithoutRender = 0;
   let nudgedOnce = false;
   let hasRendered = false;
@@ -267,7 +269,7 @@ export async function runAgentLoop(
     const t0 = performance.now();
     let streamingText = '';
     const response = await provider.chat(messages, iterationTools, {
-      signal, cacheEnabled, system: iterationSystemPrompt, maxTokens, maxTools, maxMessages, temperature, topK,
+      signal, cacheEnabled, system: iterationSystemPrompt, maxTokens, temperature, topK,
       onToken: callbacks.onToken ? (token) => {
         callbacks.onToken!(token);
         streamingText += token;
@@ -318,14 +320,6 @@ export async function runAgentLoop(
     const toolResults: ContentBlock[] = [];
     for (const block of toolBlocks) {
       const call: ToolCall = { id: block.id, name: block.name, args: block.input };
-      const wasDiscovering = discoveryPhase;
-      if (isDiscoveryTool(block.name)) {
-        discoveryPhase = true;
-        call.guided = false;
-      } else {
-        call.guided = wasDiscovering;
-        discoveryPhase = false;
-      }
       const t1 = performance.now();
 
       try {
@@ -335,12 +329,12 @@ export async function runAgentLoop(
         // Resolve alias (canonical name → real tool name) if needed
         const resolvedName = localAliasMap.get(name) ?? name;
 
-        // Parse tool name: {serverName}_{protocol}_{toolName}
-        const toolMatch = resolvedName.match(/^(.+?)_(mcp|webmcp)_(.+)$/);
+        // Parse tool name: {serverName}_{token}_{toolName} where token ∈ {data, ui}
+        const toolMatch = resolvedName.match(/^(.+?)_(data|ui)_(.+)$/);
 
         // ── Discovery cache — resolve search/list/get locally if cached ──
         if (discoveryCache && toolMatch) {
-          const cached = discoveryCache.resolve(toolMatch[1], toolMatch[3], block.input as Record<string, unknown>);
+          const cached = discoveryCache.resolve(toolMatch[1], toolMatch[3], block.input as Record<string, unknown>, trace);
           if (cached !== null) {
             result = cached;
             // Store + push result, then continue to next tool block
@@ -358,7 +352,8 @@ export async function runAgentLoop(
         // ── Intercept list_tools / search_tools (local pseudo-tools) ──
         // These are read-only discovery operations — do NOT activate the server.
         if (toolMatch && (toolMatch[3] === 'list_tools' || toolMatch[3] === 'search_tools')) {
-          const [, serverName, protocol, pseudoTool] = toolMatch;
+          const [, serverName, token, pseudoTool] = toolMatch;
+          const protocol = tokenToProtocol(token);
           const layer = (options.layers ?? []).find(l => sanitizeServerName(l.serverName) === serverName && l.protocol === protocol);
           if (!layer) {
             result = 'Error: server not found';
@@ -384,10 +379,11 @@ export async function runAgentLoop(
 
         // Parse tool name to extract server — activate on first contact
         {
-          const activateMatch = resolvedName.match(/^(.+?)_(mcp|webmcp)_(.+)$/);
+          const activateMatch = resolvedName.match(/^(.+?)_(data|ui)_(.+)$/);
           if (activateMatch) {
-            const [, serverName, protocol] = activateMatch;
-            const serverKey = `${serverName}_${protocol}`;
+            const [, serverName, token] = activateMatch;
+            const protocol = tokenToProtocol(token);
+            const serverKey = `${serverName}_${token}`;
             if (!activatedServers.has(serverKey)) {
               activatedServers.add(serverKey);
               const layer = (options.layers ?? []).find(l => sanitizeServerName(l.serverName) === serverName && l.protocol === protocol);
@@ -398,10 +394,11 @@ export async function runAgentLoop(
           }
         }
         if (!toolMatch) {
-          trace.push('dispatch', name, `unknown tool format, expected {source}_{protocol}_{tool}`, 'error');
-          result = `Error: unknown tool format "${name}". Expected {source}_{protocol}_{tool}.`;
+          trace.push('dispatch', name, `unknown tool format, expected {source}_{token}_{tool} where token in {data,ui}`, 'error');
+          result = `Error: unknown tool format "${name}". Expected {source}_{token}_{tool} where token in {data,ui}.`;
         } else {
-          const [, serverName, protocol, realToolName] = toolMatch;
+          const [, serverName, token, realToolName] = toolMatch;
+          const protocol = tokenToProtocol(token);
 
           // Auto-repair + validate params before dispatch
           let toolInput = block.input as Record<string, unknown>;
@@ -587,7 +584,7 @@ export async function runAgentLoop(
 
     // Track iterations without render — widget_display means a render happened
     const renderedThisIteration = toolBlocks.some(b => {
-      const match = b.name.match(/^.+?_(mcp|webmcp)_(.+)$/);
+      const match = b.name.match(/^.+?_(data|ui)_(.+)$/);
       return match && match[2] === 'widget_display';
     });
     if (renderedThisIteration) {