@webmcp-auto-ui/agent 2.5.20 → 2.5.22

package/package.json

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

package/src/autoui-server.ts

@@ -2,7 +2,7 @@
 // AutoUI WebMCP Server — built-in UI widgets + canvas/recall tools
 // ---------------------------------------------------------------------------
 
-import { createWebMcpServer } from '@webmcp-auto-ui/core';
+import { createWebMcpServer, parseFrontmatter } from '@webmcp-auto-ui/core';
 
 // ---------------------------------------------------------------------------
 // Inline recipes (frontmatter + body)
@@ -1007,6 +1007,17 @@ for (const recipe of RECIPES) {
   autoui.registerWidget(recipe, undefined);
 }
 
+// Expose recipe summaries to the UI browser
+const parsedRecipes = RECIPES.map((md) => {
+  const { frontmatter, body } = parseFrontmatter(md);
+  return {
+    name: (frontmatter.widget as string) ?? '',
+    description: (frontmatter.description as string) ?? '',
+    body,
+  };
+}).filter((r) => r.name);
+autoui.setRecipes(parsedRecipes);
+
 // ---------------------------------------------------------------------------
 // Custom tool: canvas
 // ---------------------------------------------------------------------------

package/src/diagnostics.ts

@@ -22,11 +22,15 @@ export function runDiagnostics(
   layers: ToolLayer[],
   tools: ProviderTool[],
   systemPrompt: string,
-  schemaOptions?: { sanitize?: boolean; flatten?: boolean },
+  schemaOptions?: { sanitize?: boolean; flatten?: boolean; strict?: boolean; providerKind?: 'remote' | 'wasm' | 'gemma' | 'local' },
   /** Original (pre-sanitize) tools — used for check #5 to detect patchable schemas */
   rawTools?: ProviderTool[],
 ): Diagnostic[] {
   const diagnostics: Diagnostic[] = [];
+  // Gemma uses a native tool-declaration format that ignores JSON-Schema features
+  // like additionalProperties, oneOf/anyOf/$ref, strict mode, etc.
+  // Skip schema-schema checks for Gemma — they produce noise without actionable value.
+  const skipSchemaChecks = schemaOptions?.providerKind === 'gemma';
 
   // 1. Tool name hygiene — check for residual "mcp"/"server" noise in prefixes
   for (const layer of layers) {
@@ -63,7 +67,9 @@ export function runDiagnostics(
   }
 
   // 3. Schema depth warning for Gemma when flatten is OFF
-  if (schemaOptions && !schemaOptions.flatten) {
+  // Skipped entirely for Gemma provider — its native format ignores schema structure beyond one level,
+  // so the "flatten" toggle has no effect there.
+  if (!skipSchemaChecks && schemaOptions && !schemaOptions.flatten) {
     for (const tool of tools) {
       const schema = tool.input_schema as Record<string, unknown>;
       if (hasNestedObjects(schema)) {
@@ -105,16 +111,19 @@ export function runDiagnostics(
 
   // 5. Strict mode — schemas that were auto-patched
   // 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({
-        severity: 'warning',
-        title: `Schema patched: ${tool.name}`,
-        detail: `${patches.length} correction(s) for strict mode: ${patches.map(p => p.path).join(', ')}. additionalProperties: false added automatically.`,
-        codeFix: `Add "additionalProperties": false to the MCP server schema for ${tool.name}.`,
-      });
+  // Skipped for Gemma — it doesn't use additionalProperties/strict mode at all.
+  if (!skipSchemaChecks) {
+    const checkTools = rawTools ?? tools;
+    for (const tool of checkTools) {
+      const { patches } = sanitizeSchemaWithReport(tool.input_schema as JsonSchema);
+      if (patches.length > 0) {
+        diagnostics.push({
+          severity: 'warning',
+          title: `Schema patched: ${tool.name}`,
+          detail: `${patches.length} correction(s) for strict mode: ${patches.map(p => p.path).join(', ')}. additionalProperties: false added automatically.`,
+          codeFix: `Add "additionalProperties": false to the MCP server schema for ${tool.name}.`,
+        });
+      }
     }
   }
 

package/src/discovery-cache.ts

@@ -69,6 +69,11 @@ export class DiscoveryCache {
     return this.servers.get(serverPrefix)?.recipes.length ?? 0;
   }
 
+  /** Get the cached recipes for a specific server prefix. */
+  recipesFor(serverPrefix: string): CachedRecipe[] {
+    return this.servers.get(serverPrefix)?.recipes ?? [];
+  }
+
   /** Tool count for a specific server */
   toolCount(serverPrefix: string): number {
     return this.servers.get(serverPrefix)?.tools.length ?? 0;
@@ -107,9 +112,12 @@ export class DiscoveryCache {
       }
 
       case 'get_recipe': {
-        const name = (params.name ?? '') as string;
-        const recipe = cache.recipes.find(r => r.name.toLowerCase() === name.toLowerCase());
-        if (!recipe) return JSON.stringify({ error: `Recipe "${name}" not found` });
+        const key = String(params.name ?? params.id ?? '').toLowerCase();
+        const recipe = cache.recipes.find(r =>
+          (r.name?.toLowerCase() === key) ||
+          ((r as Record<string, unknown>).id as string | undefined)?.toLowerCase() === key
+        );
+        if (!recipe) return JSON.stringify({ error: `Recipe "${key}" not found` });
         return JSON.stringify(recipe);
       }
 

package/src/index.ts

@@ -17,7 +17,7 @@ export { GemmaProvider } from './providers/gemma.js';
 export type { GemmaProviderOptions, GemmaStatus } from './providers/gemma.js';
 
 // Agent loop
-export { runAgentLoop, toProviderTools, mcpToolsToAnthropic, fromMcpTools, trimConversationHistory } from './loop.js';
+export { runAgentLoop, toProviderTools, fromMcpTools, trimConversationHistory } from './loop.js';
 export { buildSystemPrompt } from './tool-layers.js';
 export type { AgentLoopOptions } from './loop.js';
 
@@ -69,7 +69,7 @@ export { ContextRAG, type ContextRAGOptions } from './nano-rag/mod.js';
 // Types
 export type {
   RemoteModelId, WasmModelId, LLMId, ModelId,
-  ChatMessage, ContentBlock, McpToolDef, ProviderTool, AnthropicTool,
+  ChatMessage, ContentBlock, McpToolDef, ProviderTool,
   LLMProvider, LLMResponse, ToolCall, AgentMetrics, AgentResult, AgentCallbacks,
   Recipe, McpRecipe,
 } from './types.js';

package/src/loop.ts

@@ -68,8 +68,6 @@ function compressOldToolResults(messages: ChatMessage[], previewSize: number, re
 
 // Re-export toProviderTools
 export { toProviderTools };
-/** @deprecated Use toProviderTools */
-export const mcpToolsToAnthropic = toProviderTools;
 
 function truncateResult(result: string, maxLen: number = MAX_RESULT_LEN): string {
   if (result.length <= maxLen) return result;
@@ -113,6 +111,8 @@ export interface AgentLoopOptions {
   discoveryCache?: DiscoveryCache;
   /** Nano-RAG context compaction — ingest tool results, query before LLM calls */
   contextRAG?: import('./nano-rag/context-rag.js').ContextRAG;
+  /** Size of inline residue (chars) left in tool_result after nano-RAG ingestion. 0 = stub only. Default: 200 */
+  ragResidueSize?: number;
 }
 
 export async function runAgentLoop(
@@ -137,6 +137,7 @@ export async function runAgentLoop(
     schemaOptions,
     discoveryCache,
     contextRAG,
+    ragResidueSize = 200,
   } = options;
 
   // Buffer for recall — stores full tool results keyed by tool_use_id
@@ -536,25 +537,31 @@ export async function runAgentLoop(
         // Store full result in buffer for later recall
         resultBuffer.set(block.id, result);
 
-        // Nano-RAG: ingest tool result for future context retrieval
-        if (contextRAG && result) {
+        // Nano-RAG: ingest tool result and replace with compact stub
+        let compactedResult = result;
+        if (contextRAG && result && !isDiscoveryTool(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()
             .find(m => m.role === 'user')?.content;
           const userQuery = typeof lastUserText === 'string'
             ? lastUserText
             : (lastUserText as any[])?.find((b: any) => b.type === 'text')?.text ?? '';
-          contextRAG.ingest(realName, block.id, resultStr, userQuery).then((chunkCount) => {
+          try {
+            const chunkCount = await contextRAG.ingest(realName, block.id, resultStr, userQuery);
             if (chunkCount > 0) {
               callbacks.onTrace?.(`[nano-rag] ingested ${chunkCount} chunks from ${realName} (${resultStr.length} chars)`);
+              // Replace with compact stub — full data retrievable via RAG query
+              const residue = ragResidueSize > 0 ? resultStr.slice(0, ragResidueSize) : '';
+              compactedResult = residue
+                ? `${residue}… [${resultStr.length} chars ingested into RAG]`
+                : `[${resultStr.length} chars ingested into RAG — query context for details]`;
             }
-          }).catch(() => {});
+          } catch { /* RAG failure is non-fatal — keep full result */ }
         }
 
         call.result = result;
-        toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: result });
+        toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: compactedResult });
       } catch (e) {
         call.error = e instanceof Error ? e.message : String(e);
         toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: `Error: ${call.error}` });

package/src/providers/remote.ts

@@ -1,4 +1,4 @@
-import type { LLMProvider, LLMResponse, ChatMessage, AnthropicTool, RemoteModelId, ContentBlock } from '../types.js';
+import type { LLMProvider, LLMResponse, ChatMessage, ProviderTool, RemoteModelId, ContentBlock } from '../types.js';
 
 export interface RemoteLLMProviderOptions {
   proxyUrl: string;
@@ -34,7 +34,7 @@ export class RemoteLLMProvider implements LLMProvider {
 
   async chat(
     messages: ChatMessage[],
-    tools: AnthropicTool[],
+    tools: ProviderTool[],
     options?: { signal?: AbortSignal; cacheEnabled?: boolean; system?: string; maxTokens?: number; temperature?: number; topK?: number }
   ): Promise<LLMResponse> {
     const cache = options?.cacheEnabled ?? false;

package/src/providers/wasm.ts

@@ -3,7 +3,7 @@
  * No Web Worker needed — @mediapipe/tasks-genai is not compatible with ES module workers.
  * 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 { LLMProvider, LLMResponse, ChatMessage, ProviderTool, WasmModelId, ContentBlock } from '../types.js';
 import type { PipelineTrace } from '../pipeline-trace.js';
 
 export type WasmStatus = 'idle' | 'loading' | 'ready' | 'error';
@@ -175,7 +175,7 @@ export class WasmProvider implements LLMProvider {
 
   async chat(
     messages: ChatMessage[],
-    tools: AnthropicTool[],
+    tools: ProviderTool[],
     options?: { signal?: AbortSignal; maxTokens?: number; temperature?: number; topK?: number; onToken?: (token: string) => void; system?: string; maxTools?: number }
   ): Promise<LLMResponse> {
     if (this.status !== 'ready') await this.initialize();
@@ -201,7 +201,7 @@ export class WasmProvider implements LLMProvider {
 
   private async _chat(
     messages: ChatMessage[],
-    tools: AnthropicTool[],
+    tools: ProviderTool[],
     options?: { signal?: AbortSignal; maxTokens?: number; temperature?: number; topK?: number; onToken?: (token: string) => void; system?: string; maxTools?: number }
   ): Promise<LLMResponse> {
     // Apply per-request options
@@ -260,8 +260,6 @@ export class WasmProvider implements LLMProvider {
         let lastToken = '';
         let repeatCount = 0;
         const MAX_REPEATS = 20;
-        // P2 fix: track if we have a complete tool call to enable early cancellation
-        let hasCompleteToolCall = false;
         const TOOL_CALL_MAX_CHARS = 3000;
 
         const result = await this.inference.generateResponse(prompt, (partialResult: string, _done: boolean) => {
@@ -297,18 +295,6 @@ export class WasmProvider implements LLMProvider {
             }
           }
 
-          // Cancel immediately after complete tool call — don't let Gemma hallucinate
-          if (!hasCompleteToolCall && fullText.includes('<tool_call|>')) {
-            hasCompleteToolCall = true;
-            // Check if there's a new tool_call opening after the last closing
-            const lastEnd = fullText.lastIndexOf('<tool_call|>');
-            const afterEnd = fullText.slice(lastEnd + '<tool_call|>'.length);
-            if (!afterEnd.includes('<|tool_call>')) {
-              // No new tool call — cancel immediately
-              this.inference?.cancelProcessing();
-              return;
-            }
-          }
           // Safety: if text grows way too long, force cancel
           if (fullText.length > TOOL_CALL_MAX_CHARS * 2) {
             this.inference?.cancelProcessing();
@@ -601,7 +587,7 @@ export class WasmProvider implements LLMProvider {
   /**
    * Format a tool declaration in Gemma 4 native syntax.
    */
-  private static formatToolDeclaration(tool: AnthropicTool): string {
+  private static formatToolDeclaration(tool: ProviderTool): string {
     const q = '<|"|>';
     let decl = `<|tool>declaration:${tool.name}{\n`;
     decl += `  description:${q}${tool.description}${q}`;
@@ -671,7 +657,7 @@ export class WasmProvider implements LLMProvider {
     return `<|tool_call>call:${name}{${entries.join(',')}}<tool_call|>`;
   }
 
-  private buildPrompt(messages: ChatMessage[], tools: AnthropicTool[], systemPrompt?: string, maxTools?: number): string {
+  private buildPrompt(messages: ChatMessage[], tools: ProviderTool[], systemPrompt?: string, maxTools?: number): string {
     const systemParts: string[] = [];
 
     // Inject system prompt from settings if provided
@@ -691,16 +677,8 @@ export class WasmProvider implements LLMProvider {
           ]
         : tools;
 
-      // Minimal instruction — Gemma 4 is trained on native tool format
-      systemParts.push(`You are a UI assistant connected to MCP servers.
-Use the available tools to respond. After each DATA call, render visually with component().
-Do NOT ask for confirmation. Execute directly.`);
-
       // Native Gemma 4 tool declarations
       systemParts.push(limitedTools.map(t => WasmProvider.formatToolDeclaration(t)).join('\n'));
-
-      // Enable thinking mode — Gemma 4 reasons before tool calls
-      systemParts.push('Before each tool call, think briefly in a <|channel>thought block then call the tool.');
     }
 
     // Build a map of tool_use_id → tool_name from all messages for tool_result resolution

package/src/recipe-browser.ts

@@ -10,11 +10,16 @@ export function filterRecipes<T extends { name: string; description?: string }>(
 ): T[] {
   const q = query.trim().toLowerCase();
   if (!q) return recipes;
-  return recipes.filter(
-    (r) =>
+  return recipes.filter((r) => {
+    const srv = ((r as Record<string, unknown>).server as string | undefined)
+             ?? ((r as Record<string, unknown>).serverName as string | undefined)
+             ?? '';
+    return (
       r.name.toLowerCase().includes(q) ||
-      (r.description && r.description.toLowerCase().includes(q)),
-  );
+      (r.description && r.description.toLowerCase().includes(q)) ||
+      srv.toLowerCase().includes(q)
+    );
+  });
 }
 
 /**

package/src/tool-layers.ts

@@ -2,7 +2,7 @@
 
 import type { McpToolDef, ProviderTool } from './types.js';
 import type { McpRecipe } from './recipes/types.js';
-import type { WebMcpToolDef } from '@webmcp-auto-ui/core';
+import type { WebMcpToolDef, McpRecipeSummary } 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';
@@ -39,6 +39,7 @@ export interface WebMcpLayer {
   serverName: string;
   description: string;
   tools: WebMcpToolDef[];
+  recipes?: McpRecipeSummary[];
 }
 
 export type ToolLayer = McpLayer | WebMcpLayer;

package/src/types.ts

@@ -35,12 +35,9 @@ export interface ProviderTool {
   name: string;
   description: string;
   input_schema: Record<string, unknown>;
-  strict?: boolean;  // Anthropic strict tool use — grammar-constrained sampling
+  strict?: boolean;  // Strict tool use — grammar-constrained sampling (provider-dependent)
 }
 
-/** @deprecated Use ProviderTool */
-export type AnthropicTool = ProviderTool;
-
 export interface LLMResponse {
   content: ContentBlock[];
   stopReason: string;

package/tests/loop.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
-import { buildSystemPrompt, mcpToolsToAnthropic, fromMcpTools } from '../src/loop.js';
-import type { McpToolDef, LLMProvider, LLMResponse, AnthropicTool, ChatMessage } from '../src/types.js';
+import { buildSystemPrompt, toProviderTools, fromMcpTools } from '../src/loop.js';
+import type { McpToolDef, LLMProvider, LLMResponse, ProviderTool, ChatMessage } from '../src/types.js';
 
 const TOOLS: McpToolDef[] = [
   { name: 'search', description: 'Search for things', inputSchema: { type: 'object', properties: { q: { type: 'string' } } } },
@@ -16,12 +16,12 @@ describe('buildSystemPrompt', () => {
   });
 });
 
-describe('mcpToolsToAnthropic', () => {
+describe('toProviderTools', () => {
   it('converts tool definitions correctly', () => {
-    const anthropic = mcpToolsToAnthropic(TOOLS);
-    expect(anthropic[0].name).toBe('search');
-    expect(anthropic[0].description).toBe('Search for things');
-    expect(anthropic[0].input_schema).toBeDefined();
+    const result = toProviderTools(TOOLS);
+    expect(result[0].name).toBe('search');
+    expect(result[0].description).toBe('Search for things');
+    expect(result[0].input_schema).toBeDefined();
   });
 
   it('strips oneOf/anyOf/allOf via sanitizeSchema', () => {
@@ -30,14 +30,14 @@ describe('mcpToolsToAnthropic', () => {
       description: 'x',
       inputSchema: { type: 'object', oneOf: [{ type: 'string' }], properties: {} } as Record<string,unknown>,
     }];
-    const result = mcpToolsToAnthropic(tools);
-    expect((result[0].input_schema as Record<string, unknown>)['oneOf']).toBeUndefined();
+    const converted = toProviderTools(tools);
+    expect((converted[0].input_schema as Record<string, unknown>)['oneOf']).toBeUndefined();
   });
 
   it('falls back to empty schema when inputSchema absent', () => {
     const tools: McpToolDef[] = [{ name: 'bare', description: 'no schema' }];
-    const result = mcpToolsToAnthropic(tools);
-    expect(result[0].input_schema).toBeDefined();
+    const converted = toProviderTools(tools);
+    expect(converted[0].input_schema).toBeDefined();
   });
 });