@webmcp-auto-ui/agent 2.5.20 → 2.5.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmcp-auto-ui/agent",
-  "version": "2.5.20",
+  "version": "2.5.21",
   "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,7 +22,7 @@ export function runDiagnostics(
   layers: ToolLayer[],
   tools: ProviderTool[],
   systemPrompt: string,
-  schemaOptions?: { sanitize?: boolean; flatten?: boolean },
+  schemaOptions?: { sanitize?: boolean; flatten?: boolean; strict?: boolean },
   /** Original (pre-sanitize) tools — used for check #5 to detect patchable schemas */
   rawTools?: ProviderTool[],
 ): Diagnostic[] {

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;

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
@@ -601,7 +601,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 +671,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 +691,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();
   });
 });