@webmcp-auto-ui/agent 2.5.21 → 2.5.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webmcp-auto-ui/agent",
-  "version": "2.5.21",
+  "version": "2.5.23",
   "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';
@@ -22,11 +22,15 @@ export function runDiagnostics(
   layers: ToolLayer[],
   tools: ProviderTool[],
   systemPrompt: string,
-  schemaOptions?: { sanitize?: boolean; flatten?: boolean; strict?: 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,22 +111,71 @@ 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) {
+        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: detailParts.join(' '),
+          codeFix,
+        });
+      }
     }
   }
 
   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

@@ -112,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/providers/wasm.ts

@@ -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();