@webmcp-auto-ui/agent 2.5.36 → 2.5.37

package/package.json

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

package/src/autoui-server.ts

@@ -54,6 +54,40 @@ When the user wants to browse, search, or pick a recipe — for example "show me
 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 recipe for tool-browser (real vanilla widget)
+const toolBrowserRecipe = `---
+widget: tool-browser
+description: Interactive tool browser with search/filters/preview. Use when the user wants to browse, search, or pick a tool from connected servers.
+group: rich
+schema:
+  type: object
+  required:
+    - tools
+  properties:
+    tools:
+      type: array
+      description: List of BrowsableTool objects (name, description, server, inputSchema, ...).
+      items:
+        type: object
+    filters:
+      type: object
+      description: Initial filters
+      properties:
+        q:
+          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 tool — for example "show me the available tools".
+
+## How to use
+Call widget_display({name: "tool-browser", params: {tools: [...]}}). The widget emits a bubbling 'widget:interact' CustomEvent on user actions.
+`;
+
 // ---------------------------------------------------------------------------
 // Inline recipes (frontmatter + body)
 // ---------------------------------------------------------------------------
@@ -930,6 +964,7 @@ Call widget_display({name: "chat-input", params: {placeholder: "Your reply..."}}
 const _NOTEBOOK_RECIPE_SOURCES: string[] = [
   notebookRecipe as string,
   recipeBrowserRecipe,
+  toolBrowserRecipe,
 ];
 export const NATIVE_WIDGET_NAMES = [...RECIPES, ..._NOTEBOOK_RECIPE_SOURCES].map(r => {
   const match = r.match(/widget:\s*(\S+)/);
@@ -955,6 +990,9 @@ autoui.registerWidget(notebookRecipe as string, renderNotebook as any);
 // Recipe browser — resolved by WidgetRenderer as <auto-recipe-browser> custom element
 autoui.registerWidget(recipeBrowserRecipe, undefined);
 
+// Tool browser — resolved by WidgetRenderer as <auto-tool-browser> custom element
+autoui.registerWidget(toolBrowserRecipe, undefined);
+
 // 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/discovery-cache.ts

@@ -6,6 +6,7 @@
 
 import type { ProviderTool } from './types.js';
 import type { PipelineTrace } from './pipeline-trace.js';
+import { sanitizeServerName } from './tool-layers.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']);
@@ -30,14 +31,21 @@ export interface ServerCache {
 export class DiscoveryCache {
   private servers = new Map<string, ServerCache>();
 
+  /** Normalize a server prefix so register/lookup share the same key shape
+   *  regardless of casing, spaces, or other artifacts. Mirrors the
+   *  sanitization applied to tool name prefixes by tool-layers. */
+  private norm(serverPrefix: string): string {
+    return sanitizeServerName(serverPrefix);
+  }
+
   /** Register a server's recipes and tools */
   register(serverPrefix: string, data: ServerCache): void {
-    this.servers.set(serverPrefix, data);
+    this.servers.set(this.norm(serverPrefix), data);
   }
 
   /** Check if we have cached data for a server prefix */
   has(serverPrefix: string): boolean {
-    return this.servers.has(serverPrefix);
+    return this.servers.has(this.norm(serverPrefix));
   }
 
   /** Clear all cached data */
@@ -45,7 +53,7 @@ export class DiscoveryCache {
     this.servers.clear();
   }
 
-  /** All registered server prefixes */
+  /** All registered server prefixes (normalized) */
   serverPrefixes(): string[] {
     return [...this.servers.keys()];
   }
@@ -70,22 +78,22 @@ export class DiscoveryCache {
 
   /** Recipe count for a specific server */
   recipeCount(serverPrefix: string): number {
-    return this.servers.get(serverPrefix)?.recipes.length ?? 0;
+    return this.servers.get(this.norm(serverPrefix))?.recipes.length ?? 0;
   }
 
   /** Get the cached recipes for a specific server prefix. */
   recipesFor(serverPrefix: string): CachedRecipe[] {
-    return this.servers.get(serverPrefix)?.recipes ?? [];
+    return this.servers.get(this.norm(serverPrefix))?.recipes ?? [];
   }
 
   /** Tool count for a specific server */
   toolCount(serverPrefix: string): number {
-    return this.servers.get(serverPrefix)?.tools.length ?? 0;
+    return this.servers.get(this.norm(serverPrefix))?.tools.length ?? 0;
   }
 
   /** Tool count excluding discovery tools (hidden from user-facing browsers) */
   browsableToolCount(serverPrefix: string): number {
-    const tools = this.servers.get(serverPrefix)?.tools ?? [];
+    const tools = this.servers.get(this.norm(serverPrefix))?.tools ?? [];
     return tools.filter(t => !DISCOVERY_TOOL_NAMES.has(t.name)).length;
   }
 
@@ -103,7 +111,7 @@ export class DiscoveryCache {
     params: Record<string, unknown>,
     trace?: PipelineTrace,
   ): string | null {
-    const cache = this.servers.get(serverPrefix);
+    const cache = this.servers.get(this.norm(serverPrefix));
     if (!cache) return null;
 
     switch (realToolName) {

package/src/index.ts

@@ -32,7 +32,7 @@ export { GemmaProvider } from './providers/gemma.js';
 export type { GemmaProviderOptions, GemmaStatus } from './providers/gemma.js';
 
 // Agent loop
-export { runAgentLoop, toProviderTools, fromMcpTools, trimConversationHistory } from './loop.js';
+export { runAgentLoop, toProviderTools, fromMcpTools, trimConversationHistory, pruneOrphanToolResults } from './loop.js';
 export { buildSystemPrompt, buildSystemPromptWithAliases } from './prompts/index.js';
 export type { SystemPromptResult } from './prompts/index.js';
 export type { AgentLoopOptions } from './loop.js';
@@ -41,7 +41,7 @@ export type { AgentLoopOptions } from './loop.js';
 export { autoui, NATIVE_WIDGET_NAMES } from './autoui-server.js';
 
 // Tool layers
-export { buildToolsFromLayers, buildDiscoveryTools, buildDiscoveryToolsWithAliases, activateServerTools, resolveCanonicalTools, toolAliasMap, flattenPathMaps, buildDiscoveryCache } from './tool-layers.js';
+export { buildToolsFromLayers, buildDiscoveryTools, buildDiscoveryToolsWithAliases, activateServerTools, resolveCanonicalTools, toolAliasMap, flattenPathMaps, buildDiscoveryCache, sanitizeServerName } from './tool-layers.js';
 export type { ToolLayer, McpLayer, WebMcpLayer, DiscoveryToolsResult, SchemaTransformOptions, BuildToolsResult, ProviderKind } from './tool-layers.js';
 
 // Discovery cache

package/src/loop.ts

@@ -275,6 +275,10 @@ export async function runAgentLoop(
       }
     }
 
+    // Defensive: strip any orphan tool_result blocks before sending — strict
+    // providers (Anthropic) reject these with a 400.
+    pruneOrphanToolResults(messages);
+
     callbacks.onLLMRequest?.(messages, iterationTools);
     const t0 = performance.now();
     let streamingText = '';
@@ -456,10 +460,18 @@ export async function runAgentLoop(
             if (!client) {
               result = `Error: no MCP client available for tool ${name}`;
             } else {
-              const mcpResult = await client.callTool(realToolName, toolInput);
-              const textContent = mcpResult.content?.find((c: { type: string }) => c.type === 'text') as { text?: string } | undefined;
-              const rawResult = textContent?.text ?? JSON.stringify(mcpResult);
-              result = truncateResults ? truncateResult(rawResult, maxResultLength) : rawResult;
+              const mcpLayer = (options.layers ?? []).find(
+                l => sanitizeServerName(l.serverName) === serverName && l.protocol === 'mcp'
+              ) as { serverUrl?: string } | undefined;
+              const serverUrl = mcpLayer?.serverUrl;
+              if (!serverUrl) {
+                result = `Error: no serverUrl resolved for tool "${name}" (server "${serverName}"). Pass serverUrl on the matching ToolLayer.`;
+              } else {
+                const mcpResult = await (client as unknown as { callToolOn: (u: string, n: string, a: unknown) => Promise<{ content?: { type: string; text?: string }[] }> }).callToolOn(serverUrl, realToolName, toolInput);
+                const textContent = mcpResult.content?.find((c: { type: string }) => c.type === 'text') as { text?: string } | undefined;
+                const rawResult = textContent?.text ?? JSON.stringify(mcpResult);
+                result = truncateResults ? truncateResult(rawResult, maxResultLength) : rawResult;
+              }
             }
           } else if (protocol === 'webmcp') {
             // Intercept recall BEFORE hitting executeTool — use the local resultBuffer directly
@@ -539,6 +551,15 @@ export async function runAgentLoop(
                             const c = messages[i].content;
                             if (Array.isArray(c) && c.length === 0) messages.splice(i, 1);
                           }
+                          // Also drop pending tool_results in the current iteration whose
+                          // tool_use was just stripped from the assistant turn — otherwise
+                          // they become orphans when pushed at the end of the loop.
+                          for (let j = toolResults.length - 1; j >= 0; j--) {
+                            const b = toolResults[j];
+                            if (b.type === 'tool_result' && strippedIds.has((b as { tool_use_id: string }).tool_use_id)) {
+                              toolResults.splice(j, 1);
+                            }
+                          }
                         }
                         hasRendered = false;
                       }
@@ -663,18 +684,39 @@ export function trimConversationHistory(history: ChatMessage[], maxTokens: numbe
 
   // 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.
+  // correspond to an earlier assistant tool_use.
+  pruneOrphanToolResults(trimmed);
+
+  // Ensure the first non-system message is role=user (API requirement)
+  while (trimmed.length > 0) {
+    const firstNonSystem = trimmed.findIndex(m => m.role !== 'system');
+    if (firstNonSystem >= 0 && trimmed[firstNonSystem].role === 'assistant') {
+      trimmed.splice(firstNonSystem, 1);
+    } else {
+      break;
+    }
+  }
+
+  return trimmed;
+}
+
+/**
+ * Strip orphan tool_result blocks (whose tool_use_id has no matching tool_use
+ * in any preceding assistant message) and drop user messages that become
+ * empty as a result. Mutates `messages` in place.
+ *
+ * Strict providers (Anthropic API) reject orphans with a 400. This guard
+ * runs immediately before each provider call.
+ */
+export function pruneOrphanToolResults(messages: ChatMessage[]): void {
   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
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
     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;
@@ -682,21 +724,8 @@ export function trimConversationHistory(history: ChatMessage[], maxTokens: numbe
       }) 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);
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const c = messages[i].content;
+    if (Array.isArray(c) && c.length === 0) messages.splice(i, 1);
   }
-
-  // Ensure the first non-system message is role=user (API requirement)
-  while (trimmed.length > 0) {
-    const firstNonSystem = trimmed.findIndex(m => m.role !== 'system');
-    if (firstNonSystem >= 0 && trimmed[firstNonSystem].role === 'assistant') {
-      trimmed.splice(firstNonSystem, 1);
-    } else {
-      break;
-    }
-  }
-
-  return trimmed;
 }

package/src/tool-layers.ts

@@ -261,10 +261,9 @@ export function toProviderTools(tools: McpToolDef[], schemaOptions?: SchemaTrans
         }
       }
     }
-    const schemaObj = schema as Record<string, unknown>;
-    // Ensure root schema has additionalProperties for strict mode
+    let schemaObj = schema as Record<string, unknown>;
     if (schemaObj.type === 'object' && !('additionalProperties' in schemaObj)) {
-      schemaObj.additionalProperties = false;
+      schemaObj = { ...schemaObj, additionalProperties: false };
     }
     return {
       name: t.name,