@webmcp-auto-ui/agent 2.5.22 → 2.5.24

package/package.json

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

package/src/diagnostics.ts

@@ -4,7 +4,7 @@ import type { ToolLayer } from './tool-layers.js';
 import type { ProviderTool } from './types.js';
 import { sanitizeServerName } from './tool-layers.js';
 import { sanitizeSchemaWithReport } from '@webmcp-auto-ui/core';
-import type { JsonSchema } from '@webmcp-auto-ui/core';
+import type { JsonSchema, SchemaPatch } from '@webmcp-auto-ui/core';
 
 export interface Diagnostic {
   severity: 'error' | 'warning';
@@ -117,11 +117,45 @@ export function runDiagnostics(
     for (const tool of checkTools) {
       const { patches } = sanitizeSchemaWithReport(tool.input_schema as JsonSchema);
       if (patches.length > 0) {
+        const addedPatches = patches.filter((p: SchemaPatch) => p.type === 'additionalProperties');
+        const removedPatches = patches.filter((p: SchemaPatch) => p.type === 'removed');
+
+        // Dedupe paths (with multiplier) for additionalProperties patches
+        const addedPathsFmt = formatCounted(addedPatches.map(p => p.path));
+        // Dedupe "keyword@path" entries for removed patches
+        const removedEntriesFmt = formatCounted(
+          removedPatches.map(p => `${p.keyword ?? 'unknown'}@${p.path}`),
+        );
+        const removedKeywords = Array.from(
+          new Set(removedPatches.map(p => p.keyword).filter((k): k is string => !!k)),
+        );
+
+        const detailParts: string[] = [];
+        if (addedPatches.length > 0) {
+          detailParts.push(
+            `${addedPatches.length} correction(s) for strict mode at ${addedPathsFmt}: additionalProperties: false added automatically.`,
+          );
+        }
+        if (removedPatches.length > 0) {
+          detailParts.push(
+            `${removedPatches.length} keyword(s) removed for strict mode: ${removedEntriesFmt}.`,
+          );
+        }
+
+        let codeFix: string;
+        if (addedPatches.length > 0 && removedPatches.length === 0) {
+          codeFix = `Add "additionalProperties": false to the MCP server schema for ${tool.name}.`;
+        } else if (removedPatches.length > 0 && addedPatches.length === 0) {
+          codeFix = `Remove unsupported JSON Schema keywords (${removedKeywords.join(', ')}) from the MCP server schema for ${tool.name}, or accept that Claude strict mode will ignore them.`;
+        } else {
+          codeFix = `Add "additionalProperties": false and remove unsupported keywords (${removedKeywords.join(', ')}) from the MCP server schema for ${tool.name}.`;
+        }
+
         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}.`,
+          detail: detailParts.join(' '),
+          codeFix,
         });
       }
     }
@@ -130,6 +164,18 @@ export function runDiagnostics(
   return diagnostics;
 }
 
+/**
+ * Dedupe a list of entries and format with a count multiplier when > 1.
+ * ["a", "a", "b"] → "a ×2, b"
+ */
+function formatCounted(entries: string[]): string {
+  const counts = new Map<string, number>();
+  for (const e of entries) counts.set(e, (counts.get(e) ?? 0) + 1);
+  return Array.from(counts.entries())
+    .map(([entry, n]) => (n > 1 ? `${entry} ×${n}` : entry))
+    .join(', ');
+}
+
 /** Check if a JSON schema has nested object properties (depth > 1) */
 function hasNestedObjects(schema: Record<string, unknown>): boolean {
   const props = schema.properties as Record<string, Record<string, unknown>> | undefined;

package/src/discovery-cache.ts

@@ -6,6 +6,9 @@
 
 import type { ProviderTool } from './types.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']);
+
 export interface CachedRecipe {
   name: string;
   description?: string;
@@ -79,6 +82,12 @@ export class DiscoveryCache {
     return this.servers.get(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 ?? [];
+    return tools.filter(t => !DISCOVERY_TOOL_NAMES.has(t.name)).length;
+  }
+
   /**
    * Try to resolve a discovery tool call from cache.
    * Returns the result string if handled, or null if not a discovery tool.

package/src/index.ts

@@ -29,7 +29,7 @@ export { buildToolsFromLayers, buildDiscoveryTools, buildDiscoveryToolsWithAlias
 export type { ToolLayer, McpLayer, WebMcpLayer, SystemPromptResult, DiscoveryToolsResult, SchemaTransformOptions, BuildToolsResult } from './tool-layers.js';
 
 // Discovery cache
-export { DiscoveryCache } from './discovery-cache.js';
+export { DiscoveryCache, DISCOVERY_TOOL_NAMES } from './discovery-cache.js';
 export type { CachedRecipe, ServerCache } from './discovery-cache.js';
 
 // Re-export core WebMCP types

package/src/tool-layers.ts

@@ -465,6 +465,8 @@ Unless a recipe specifies otherwise, use these tools to display your responses o
 
 ${actionTools.join('\n')}
 
+widget_display may ONLY be called with data returned by a non-autoui DATA tool actually invoked in the current session. Fabricating IDs, URLs, names, dates, or any content not returned by a tool is a critical violation. If no DATA tool has been called yet, go back to STEP 1.
+
 STEP 5 — Fallback
 
 If previous steps failed, fall back to a classic chat without tool calling.`;