@webmcp-auto-ui/agent 2.5.21 → 2.5.22

package/package.json

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

package/src/diagnostics.ts

@@ -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,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

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