@webmcp-auto-ui/agent 2.5.26 → 2.5.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmcp-auto-ui/agent",
-  "version": "2.5.26",
+  "version": "2.5.28",
   "description": "LLM agent loop + remote/WASM/local providers + MCP wrapper",
   "license": "AGPL-3.0-or-later",
   "type": "module",
@@ -11,7 +11,7 @@
       "import": "./src/index.ts"
     },
     "./server": {
-      "import": "./src/server/llmProxy.ts"
+      "import": "./src/server/index.ts"
     }
   },
   "scripts": {
@@ -27,5 +27,13 @@
     "@webmcp-auto-ui/core": "file:../core",
     "onnxruntime-web": "^1.24.3",
     "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "vega-embed": "^6.24.0"
+  },
+  "peerDependenciesMeta": {
+    "vega-embed": {
+      "optional": true
+    }
   }
 }

package/src/autoui-server.ts

@@ -5,6 +5,65 @@
 import { createWebMcpServer, parseFrontmatter } from '@webmcp-auto-ui/core';
 import { RAW_RECIPES } from './recipes/_generated.js';
 
+// Notebook widget recipes (vanilla renderers) — moved to @webmcp-auto-ui/ui
+// @ts-ignore — Vite raw imports, not resolved by tsc
+import compactRecipe from '@webmcp-auto-ui/ui/widgets/notebook/recipes/compact.md?raw';
+// @ts-ignore
+import workspaceRecipe from '@webmcp-auto-ui/ui/widgets/notebook/recipes/workspace.md?raw';
+// @ts-ignore
+import documentRecipe from '@webmcp-auto-ui/ui/widgets/notebook/recipes/document.md?raw';
+// @ts-ignore
+import editorialRecipe from '@webmcp-auto-ui/ui/widgets/notebook/recipes/editorial.md?raw';
+
+// Notebook widget renderers (vanilla JS) — import via subpath to avoid pulling
+// the .svelte exports of the ui package root through tsc.
+import { render as renderCompact } from '@webmcp-auto-ui/ui/widgets/notebook/compact.js';
+import { render as renderWorkspace } from '@webmcp-auto-ui/ui/widgets/notebook/workspace.js';
+import { render as renderDocument } from '@webmcp-auto-ui/ui/widgets/notebook/document.js';
+import { render as renderEditorial } from '@webmcp-auto-ui/ui/widgets/notebook/editorial.js';
+import { render as renderRecipeBrowser } from '@webmcp-auto-ui/ui/widgets/notebook/recipe-browser.js';
+
+// Inline recipe for recipe-browser (real vanilla widget)
+const recipeBrowserRecipe = `---
+widget: recipe-browser
+description: Interactive recipe browser with search, kind/tag filters, preview and pick. Use when the user wants to browse, search, or select recipes from connected servers.
+group: rich
+schema:
+  type: object
+  required:
+    - recipes
+  properties:
+    recipes:
+      type: array
+      description: List of Recipe objects (id, name, description, body, servers, ...).
+      items:
+        type: object
+    filters:
+      type: object
+      description: Initial filters
+      properties:
+        q:
+          type: string
+        kind:
+          type: string
+          enum: [all, webmcp, mcp]
+        tags:
+          type: array
+          items:
+            type: string
+    layout:
+      type: string
+      enum: [list, grid]
+      description: Default layout (default list)
+---
+
+## When to use
+When the user wants to browse, search, or pick a recipe — for example "show me the available recipes" or "let me choose a recipe".
+
+## How to use
+Call widget_display({name: "recipe-browser", params: {recipes: [...], layout: "list"}}). The widget emits a bubbling 'widget:interact' CustomEvent with detail={action:"pick", payload: recipe} when the user clicks Pick.
+`;
+
 // ---------------------------------------------------------------------------
 // Inline recipes (frontmatter + body)
 // ---------------------------------------------------------------------------
@@ -920,77 +979,21 @@ Pour des visualisations custom, animations, ou prototypes interactifs en JS pur.
 Call widget_display({name: "js-sandbox", params: {code: "document.getElementById('root').innerHTML = '<h1>Hello</h1>'"}}).
 `,
 
-  // ── recipe-browser ──────────────────────────────────────────────────────
-  `---
-widget: recipe-browser
-description: Displays available recipes as interactive cards and allows browsing each recipe's details.
-group: rich
-schema:
-  type: object
-  required:
-    - cards
-  properties:
-    title:
-      type: string
-    cards:
-      type: array
-      items:
-        type: object
-        required:
-          - title
-        properties:
-          title:
-            type: string
-          description:
-            type: string
-          tags:
-            type: array
-            items:
-              type: string
-          meta:
-            type: object
-            properties:
-              recipe_name:
-                type: string
-              server:
-                type: string
-    interactive:
-      type: boolean
----
-
-## When to use
-Quand l'utilisateur veut voir les recettes disponibles, explorer les possibilites du serveur, ou comprendre comment utiliser un widget specifique.
-
-## Comment
-
-### Etape 1 — Lister les recettes
-Appelle search_recipes() sur chaque serveur connecte (MCP et WebMCP) pour obtenir la liste des recettes.
-
-### Etape 2 — Afficher en cartes interactives
-Utilise widget_display({name: "cards", params: {...}}) avec le parametre interactive: true pour rendre les cartes cliquables :
-widget_display({name: "cards", params: {title: "Recettes disponibles", cards: [{title: "Nom", description: "Description", tags: ["serveur"], meta: {recipe_name: "nom_technique", server: "nom_serveur"}}], interactive: true}})
-
-Le champ meta est important : il sera renvoye dans l'evenement d'interaction quand l'utilisateur clique sur la carte.
-
-### Etape 3 — Reagir au clic
-Quand l'utilisateur clique sur une carte, tu recevras un message d'interaction contenant les donnees de meta. Utilise meta.recipe_name et meta.server pour :
-1. Appeler get_recipe(meta.recipe_name) sur le bon serveur
-2. Afficher le contenu dans un widget code avec lang: 'markdown'
-3. Lier les deux widgets : reutiliser le widget detail existant via canvas('update', ...) au lieu d'en creer un nouveau a chaque clic.
-
-## Common mistakes
-- Ne pas oublier interactive: true dans les cartes — sans ca, les clics ne remontent pas
-- Ne pas creer un nouveau widget detail a chaque clic — reutiliser l'existant via canvas('update', ...)
-- Les recettes MCP et WebMCP ont des noms de serveur differents — utiliser le bon prefixe pour get_recipe()
-`,
 ];
 
 // ---------------------------------------------------------------------------
 // Native widget names — derived from RECIPES frontmatter
 // ---------------------------------------------------------------------------
 
-/** Derived from RECIPES frontmatter — always in sync with registered widgets */
-export const NATIVE_WIDGET_NAMES = RECIPES.map(r => {
+/** Derived from RECIPES + notebook widget recipes — always in sync with registered widgets */
+const _NOTEBOOK_RECIPE_SOURCES: string[] = [
+  compactRecipe as string,
+  workspaceRecipe as string,
+  documentRecipe as string,
+  editorialRecipe as string,
+  recipeBrowserRecipe,
+];
+export const NATIVE_WIDGET_NAMES = [...RECIPES, ..._NOTEBOOK_RECIPE_SOURCES].map(r => {
   const match = r.match(/widget:\s*(\S+)/);
   return match ? match[1] : '';
 }).filter(Boolean) as string[];
@@ -1008,6 +1011,18 @@ 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],
+  [recipeBrowserRecipe, renderRecipeBrowser],
+];
+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)) {

package/src/index.ts

@@ -3,10 +3,25 @@
 // Providers
 export { RemoteLLMProvider } from './providers/remote.js';
 export type { RemoteLLMProviderOptions } from './providers/remote.js';
-export { WasmProvider, buildGemmaPrompt } from './providers/wasm.js';
-export type { WasmProviderOptions, WasmStatus, BuildGemmaPromptInput } from './providers/wasm.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, listCachedModels, clearAllModelCaches, walkDirectoryStats } from './util/opfs-cache.js';
+export type { ModelFileSpec, CacheProgress, CachedModelInfo } from './util/opfs-cache.js';
+export { listAllStorage, deleteStorageEntry, clearAllStorage } from './util/storage-inventory.js';
+export type { StorageEntry, StorageSource } from './util/storage-inventory.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 { HawkProvider } from './providers/hawk.js';
+export type { HawkLLMProviderOptions } from './providers/hawk.js';
+export { HAWK_MODELS, listHawkModels, type HawkModelEntry } from './providers/hawk-models.js';
 export { createProvider } from './providers/factory.js';
 export type { LLMConfig } from './providers/factory.js';
 
@@ -18,15 +33,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, ProviderKind } 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 +79,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;
 
@@ -122,7 +123,7 @@ export interface AgentLoopOptions {
 }
 
 export async function runAgentLoop(
-  userMessage: string,
+  userMessage: string | ContentBlock[],
   options: AgentLoopOptions
 ): Promise<AgentResult> {
   const {
@@ -167,6 +168,9 @@ export async function runAgentLoop(
   // Use local alias maps (parallel-safe — no global singleton)
   const activatedServers = new Set<string>();
   const localAliasMap = new Map<string, string>();
+  // Snapshot pathMaps locally (parallel-safe). Reading the global flattenPathMaps
+  // singleton at dispatch-time races when two loops run concurrently.
+  const localPathMaps = new Map<string, Record<string, string[]>>(flattenPathMaps);
   const trace = new PipelineTrace();
 
   const disc = buildDiscoveryToolsWithAliases(options.layers ?? [], schemaOptions, trace);
@@ -209,7 +213,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;
@@ -228,17 +231,24 @@ export async function runAgentLoop(
     // After 5+ iterations without render, inject a nudge message (once)
     // Merge into existing user message if the last message is already role=user (to avoid consecutive user messages)
     if (iterationsWithoutRender >= 5 && !hasRendered && !nudgedOnce) {
-      nudgedOnce = true;
       const nudgeText = 'STOP exploration. Use the data you already collected. Call widget_display() NOW to display results.';
       const lastMsg = messages[messages.length - 1];
-      if (lastMsg && lastMsg.role === 'user') {
-        if (typeof lastMsg.content === 'string') {
-          lastMsg.content = [{ type: 'text', text: lastMsg.content }, { type: 'text', text: nudgeText }];
-        } else if (Array.isArray(lastMsg.content)) {
-          (lastMsg.content as ContentBlock[]).push({ type: 'text', text: nudgeText });
+      // Skip if last turn carries tool_result blocks — mixing raw text with tool_response
+      // in one turn violates Gemma spec §7 (the serializer would emit text + <|tool_response|>
+      // together). Defer the nudge to a later iteration where the turn is pure-user.
+      const lastHasToolResult = lastMsg && Array.isArray(lastMsg.content)
+        && (lastMsg.content as ContentBlock[]).some(b => b.type === 'tool_result');
+      if (!lastHasToolResult) {
+        nudgedOnce = true;
+        if (lastMsg && lastMsg.role === 'user') {
+          if (typeof lastMsg.content === 'string') {
+            lastMsg.content = [{ type: 'text', text: lastMsg.content }, { type: 'text', text: nudgeText }];
+          } else if (Array.isArray(lastMsg.content)) {
+            (lastMsg.content as ContentBlock[]).push({ type: 'text', text: nudgeText });
+          }
+        } else {
+          messages.push({ role: 'user', content: nudgeText });
         }
-      } else {
-        messages.push({ role: 'user', content: nudgeText });
       }
     }
 
@@ -320,14 +330,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 {
@@ -409,8 +411,11 @@ export async function runAgentLoop(
           const protocol = tokenToProtocol(token);
 
           // Auto-repair + validate params before dispatch
+          // Resolve from the full activeTools (not iterationTools, which may be filtered
+          // to strip discovery tools after 4 iterations — would make toolDef undefined
+          // and silently skip auto-repair + schema validation).
           let toolInput = block.input as Record<string, unknown>;
-          const toolDef = iterationTools.find(t => t.name === block.name);
+          const toolDef = activeTools.find(t => t.name === block.name);
           if (toolDef?.input_schema) {
             const repair = autoRepairParams(toolInput, toolDef.input_schema, realToolName);
             if (repair.fixes.length > 0) {
@@ -459,8 +464,9 @@ export async function runAgentLoop(
                 result = `Error: no WebMCP server "${serverName}" found.`;
               } else {
                 // Unflatten params if schema was flattened
+                // Use the local snapshot (parallel-safe) rather than the global singleton.
                 if (schemaOptions?.flatten) {
-                  const pathMap = flattenPathMaps.get(block.name);
+                  const pathMap = localPathMaps.get(block.name);
                   if (pathMap) {
                     toolInput = unflattenParams(toolInput, pathMap);
                   }
@@ -646,18 +652,31 @@ export function trimConversationHistory(history: ChatMessage[], maxTokens: numbe
     total -= removed.reduce((s, m) => s + JSON.stringify(m).length, 0);
   }
 
-  // Remove orphaned tool_result messages at the start — these reference
-  // a tool_use in a message that was trimmed away, causing API errors.
-  while (trimmed.length > 0) {
-    const first = trimmed[0];
-    if (first.role === 'system') break; // preserve system messages at the front
-    const blocks = Array.isArray(first.content) ? first.content : [];
-    const hasToolResult = blocks.some((b: any) => b.type === 'tool_result');
-    if (hasToolResult) {
-      trimmed.shift();
-    } else {
-      break;
+  // Remove orphaned tool_result blocks anywhere in history — strict providers
+  // (Anthropic, etc.) reject tool_result blocks whose tool_use_id does not
+  // correspond to an earlier assistant tool_use. Head-only pruning misses
+  // internal orphans caused by mid-history trims.
+  const validToolUseIds = new Set<string>();
+  for (let i = 0; i < trimmed.length; i++) {
+    const msg = trimmed[i];
+    // Collect tool_use ids from assistant messages seen so far
+    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+      for (const b of msg.content as any[]) {
+        if (b?.type === 'tool_use' && typeof b.id === 'string') validToolUseIds.add(b.id);
+      }
     }
+    // Filter out orphan tool_result blocks in user messages
+    if (msg.role === 'user' && Array.isArray(msg.content)) {
+      msg.content = (msg.content as any[]).filter(b => {
+        if (b?.type !== 'tool_result') return true;
+        return typeof b.tool_use_id === 'string' && validToolUseIds.has(b.tool_use_id);
+      }) as any;
+    }
+  }
+  // Drop user messages that became empty after orphan-pruning
+  for (let i = trimmed.length - 1; i >= 0; i--) {
+    const c = trimmed[i].content;
+    if (Array.isArray(c) && c.length === 0) trimmed.splice(i, 1);
   }
 
   // Ensure the first non-system message is role=user (API requirement)

package/src/prompts/claude-prompt-builder.ts

@@ -0,0 +1,81 @@
+// Claude / generic 5-STEP system prompt template.
+
+import type { PromptRefs } from './tool-refs.js';
+
+export function buildClaudePrompt(refs: PromptRefs): string {
+  const { listRecipes, searchRecipes, listTools, searchTools, getRecipes, actionTools } = refs;
+
+  return `You are FLEX, an AI assistant that helps users by answering their questions and completing tasks using recipes (also called skills) which are procedures containing instructions for AI agents to use tools (functions, scripts, schemas, and other relevant information) and tools. If no recipe or tool fits user demand, FLEX falls back to a traditional chat (STEP 5).
+
+There are two kinds of servers: MCP servers exposing DATA (database, images, text, json) with tool calls and WebMCP servers exposing UI (widget_display, canvas, recall) with other tool calls to render DATA on the canvas. Both servers have recipes describing how to best use their tools.
+
+CRITICAL RULE: FLEX does not narrate its process in the response. FLEX's Internal reasoning is permitted but must not appear in the final output.
+
+FLEX follows a multi-step lazy-loading protocol:
+
+STEP 1 — FLEX lists all recipes
+
+FLEX tries to fetch a relevant DATA or UI recipe using these functions:
+
+${listRecipes.join('\n')}
+
+If at least one relevant recipe is found → FLEX goes to STEP 2.
+If no results → FLEX goes to STEP 1b.
+
+STEP 1b — FLEX search recipes
+
+If FLEX does not find appropriate recipe by listing, FLEX searches an appropriate DATA or UI recipe with keyword(s) extracted from the request with these functions:
+
+${searchRecipes.join('\n')}
+
+FLEX picks the most relevant recipe for the request.
+If a recipe matches → FLEX goes to STEP 2.
+If no recipe is available or relevant → FLEX goes to STEP 1c.
+
+STEP 1c — FLEX lists tools
+
+If FLEX does not find any applicable recipe, FLEX lists relevant tools using these functions:
+
+${listTools.join('\n')}
+
+If FLEX finds a relevant tool → FLEX uses it directly in STEP 3.
+If FLEX does not find any relevant tools by listing them → FLEX goes to STEP 1d.
+
+STEP 1d — FLEX searches tools using these functions:
+
+${searchTools.join('\n')}
+
+FLEX picks the most relevant tool(s) and use it directly in STEP 3.
+
+STEP 2 — FLEX ingests the recipe in its context
+
+${getRecipes.join('\n')}
+
+FLEX knows tools functions arguments or schemas because they come from the result of list_recipes (STEP 1) or search_recipes (STEP 1b), whichever was called by FLEX. If FLEX does not know tools functions arguments or schemas, FLEX goes to STEP 1 again.
+
+If the recipe references other recipes by name (e.g. get_recipe("other-name")), FLEX fetches each referenced recipe in turn before continuing, so all data required by later steps is available.
+
+If FLEX knows tool functions arguments or schemas, FLEX also reads the full instructions of the selected recipe and executes them directly in STEP 3.
+
+STEP 3 — FLEX executes tool functions
+
+FLEX prefers recipes over direct tool calls when a recipe matches the task. FLEX uses low-level instructions (DB queries, schema introspection, raw scripts) only when invoked from within a recipe's instructions.
+
+FLEX follows recipe instructions exactly if they are present. Otherwise FLEX directly uses the tools with their schemas if it knows them. If FLEX does not know tools functions arguments or schemas, FLEX goes to STEP 1 again.
+
+Placeholder markers in recipes like <step 1>, <step 2>, <jsCode from step 2 verbatim> are slots: FLEX replaces them with the real values returned by earlier tool calls, keeping the original text verbatim where the recipe specifies.
+
+Output format: (1) FLEX returns a one-sentence summary of the action performed, then (2) FLEX display the result usually as a UI element such as a widget in STEP 4.
+
+STEP 4 — UI display
+
+Unless a recipe specifies otherwise, FLEX uses these functions to display its responses on the canvas:
+
+${actionTools.join('\n')}
+
+FLEX knows that widget_display may ONLY be called with data returned by a DATA tool actually invoked in the current session. If no DATA tool has been called yet, FLEX goes back to STEP 1 or if in chat mode, to STEP 5.
+
+STEP 5 — Fallback
+
+If previous steps failed, FLEX falls back to a classic chat without tool calling.`;
+}