omnius 1.0.303 → 1.0.304

package/dist/index.js

@@ -570676,6 +570676,134 @@ Rewrite it now for ${ctx3.model}.`;
         }
         return null;
       }
+      buildToolArgumentRepairFeedback(toolName, args, tool, validationError) {
+        const parameters = tool.parameters ?? {};
+        const props = this.schemaProperties(parameters);
+        const required = this.schemaRequired(parameters);
+        const providedKeys = Object.keys(args ?? {}).filter((key) => !key.startsWith("_"));
+        const missingRequired = required.filter((field) => args[field] === void 0 || args[field] === null);
+        const unknownKeys = providedKeys.filter((key) => !props.has(key));
+        const aliases = this.suggestArgumentAliases(missingRequired, providedKeys, args, props);
+        const corrected = this.buildCorrectedArgsPreview(args, props, aliases);
+        const siblingMatches = this.findSiblingToolSchemaMatches(toolName, providedKeys);
+        const lines = [
+          `[RUNTIME TOOL ARGUMENT REPAIR]`,
+          `Tool call failed before execution: ${toolName}`,
+          `Validation error: ${validationError}`
+        ];
+        if (required.length > 0) {
+          lines.push(`Required keys for ${toolName}: ${required.join(", ")}`);
+        }
+        if (providedKeys.length > 0) {
+          lines.push(`Provided keys: ${providedKeys.join(", ")}`);
+        }
+        if (unknownKeys.length > 0) {
+          lines.push(`Keys not accepted by ${toolName}: ${unknownKeys.join(", ")}`);
+        }
+        if (aliases.length > 0) {
+          for (const alias of aliases) {
+            lines.push(`Repair: use \`${alias.to}\` instead of \`${alias.from}\` for ${toolName}.`);
+          }
+          lines.push(`Corrected argument shape: ${JSON.stringify(corrected)}`);
+        } else if (missingRequired.length > 0) {
+          lines.push(`Repair: include missing required key(s): ${missingRequired.join(", ")}.`);
+        }
+        if (siblingMatches.length > 0) {
+          lines.push(`Schema mismatch hint: these arguments match ${siblingMatches.map((name10) => `\`${name10}\``).join(", ")} better than \`${toolName}\`. Either call the matching tool, or rewrite the arguments to the ${toolName} schema.`);
+        }
+        lines.push(`Do not repeat ${toolName} with the same invalid key set. The previous call did not reach the tool implementation.`);
+        const systemGuidance = lines.join("\n");
+        return {
+          error: `Invalid arguments for ${toolName}: ${validationError}. Runtime repair guidance was injected for the next turn.`,
+          llmContent: systemGuidance,
+          systemGuidance
+        };
+      }
+      schemaProperties(parameters) {
+        const raw = parameters.properties;
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+          return /* @__PURE__ */ new Set();
+        }
+        return new Set(Object.keys(raw));
+      }
+      schemaRequired(parameters) {
+        const raw = parameters.required;
+        return Array.isArray(raw) ? raw.filter((item) => typeof item === "string") : [];
+      }
+      suggestArgumentAliases(missingRequired, providedKeys, args, acceptedKeys) {
+        const suggestions = [];
+        const provided = new Set(providedKeys);
+        const aliasMap = {
+          task: ["prompt", "description", "message", "query", "input", "instructions"],
+          prompt: ["task", "message", "query", "input", "text", "instructions"],
+          background: ["run_in_background", "background_run", "async"],
+          run_in_background: ["background", "background_run", "async"],
+          max_turns: ["maxTurns", "turns"],
+          timeout_ms: ["timeoutMs", "timeout"],
+          path: ["file", "filepath", "file_path", "filename"],
+          command: ["cmd", "shell_command"],
+          query: ["prompt", "task", "message", "input", "text"]
+        };
+        for (const required of missingRequired) {
+          for (const alias of aliasMap[required] ?? []) {
+            if (provided.has(alias) && args[alias] !== void 0) {
+              suggestions.push({ from: alias, to: required });
+              break;
+            }
+          }
+        }
+        for (const key of providedKeys) {
+          if (acceptedKeys.has(key))
+            continue;
+          for (const accepted of acceptedKeys) {
+            const aliases = aliasMap[accepted] ?? [];
+            if (aliases.includes(key) && args[key] !== void 0) {
+              if (!suggestions.some((s2) => s2.from === key && s2.to === accepted)) {
+                suggestions.push({ from: key, to: accepted });
+              }
+              break;
+            }
+          }
+        }
+        return suggestions;
+      }
+      buildCorrectedArgsPreview(args, acceptedKeys, aliases) {
+        const corrected = {};
+        for (const [key, value2] of Object.entries(args ?? {})) {
+          if (acceptedKeys.has(key))
+            corrected[key] = value2;
+        }
+        for (const alias of aliases) {
+          if (corrected[alias.to] === void 0 && args[alias.from] !== void 0) {
+            corrected[alias.to] = args[alias.from];
+          }
+        }
+        return corrected;
+      }
+      findSiblingToolSchemaMatches(requestedToolName, providedKeys) {
+        if (providedKeys.length === 0)
+          return [];
+        const provided = new Set(providedKeys);
+        const matches = [];
+        for (const candidate of this.tools.values()) {
+          if (candidate.name === requestedToolName)
+            continue;
+          const props = this.schemaProperties(candidate.parameters ?? {});
+          if (props.size === 0)
+            continue;
+          const required = this.schemaRequired(candidate.parameters ?? {});
+          const matched = providedKeys.filter((key) => props.has(key)).length;
+          if (matched === 0)
+            continue;
+          const requiredPresent = required.filter((key) => provided.has(key)).length;
+          const requiredSatisfied = required.length === 0 || requiredPresent === required.length;
+          const score = matched * 2 + requiredPresent * 3 + (requiredSatisfied ? 3 : 0) - Math.max(0, required.length - requiredPresent);
+          if (score >= 5 || matched >= 2 && requiredSatisfied) {
+            matches.push({ name: candidate.name, score });
+          }
+        }
+        return matches.sort((a2, b) => b.score - a2.score).slice(0, 3).map((match) => match.name);
+      }
       unknownToolError(name10) {
         const names = Array.from(this.tools.values()).map((tool) => tool.aliases?.length ? `${tool.name} (aliases: ${tool.aliases.join("|")})` : tool.name).sort();
         const preview = names.slice(0, 80).join(", ");
@@ -574012,6 +574140,7 @@ Corrective action: try a different approach first: read relevant files, adjust a
               const resolvedTool = this.lookupRegisteredTool(tc.name);
               const tool = resolvedTool?.tool;
               let result;
+              let runtimeSystemGuidance = null;
               if (repeatShortCircuit) {
                 result = repeatShortCircuit;
               } else if (tc.arguments && "_raw" in tc.arguments) {
@@ -574046,10 +574175,14 @@ Corrective action: try a different approach first: read relevant files, adjust a
                   validationError = await this.validateToolInput(tool, tc.arguments, resolvedTool?.name ?? tc.name);
                 }
                 if (validationError) {
+                  const repair = this.buildToolArgumentRepairFeedback(tc.name, tc.arguments, tool, validationError);
+                  runtimeSystemGuidance = repair.systemGuidance;
                   result = {
                     success: false,
                     output: "",
-                    error: `Invalid arguments for ${tc.name}: ${validationError}. Check the parameter types and try again.`
+                    error: repair.error,
+                    llmContent: repair.llmContent,
+                    runtimeAuthored: true
                   };
                 } else {
                   const violations = checkConstraints(tc.name, tc.arguments);
@@ -575402,7 +575535,12 @@ Then use file_read on individual FILES inside it.`);
                 outputPreview: (result.output ?? result.error ?? "").toString().slice(0, 500),
                 timestamp: (/* @__PURE__ */ new Date()).toISOString()
               });
-              return { tc, output, success: result.success };
+              return {
+                tc,
+                output,
+                success: result.success,
+                ...runtimeSystemGuidance ? { systemGuidance: runtimeSystemGuidance } : {}
+              };
             };
             const rawToolCalls = msg.toolCalls;
             if (this.options.streamEnabled && this._streamingExecutor.hasTools) {
@@ -575436,7 +575574,8 @@ Then use file_read on individual FILES inside it.`);
                   return {
                     success: r2.success,
                     output: r2.output,
-                    error: r2.success ? void 0 : r2.output
+                    error: r2.success ? void 0 : r2.output,
+                    systemGuidance: r2.systemGuidance
                   };
                 })();
                 streamFpInFlight.set(_fp, _run);
@@ -575524,6 +575663,12 @@ ${sr.result.output}`;
                   const r2 = await executeSingle(tc);
                   if (r2) {
                     messages2.push(this.buildToolMessage(r2.output, r2.tc.id, r2.tc.name));
+                    if (r2.systemGuidance) {
+                      messages2.push({
+                        role: "system",
+                        content: r2.systemGuidance
+                      });
+                    }
                     if (r2.tc.name === "task_complete") {
                       if (!r2.success) {
                         messages2.push({
@@ -575629,6 +575774,12 @@ ${sr.result.output}`;
                 for (const r2 of results) {
                   if (r2) {
                     messages2.push(this.buildToolMessage(r2.output, r2.tc.id, r2.tc.name));
+                    if (r2.systemGuidance) {
+                      messages2.push({
+                        role: "system",
+                        content: r2.systemGuidance
+                      });
+                    }
                     if (r2.tc.name === "task_complete") {
                       if (!r2.success) {
                         messages2.push({
@@ -577501,6 +577652,11 @@ ${marker}` : marker);
       normalizeToolOutput(result, toolName, args, turn) {
         const { toolOutputMaxChars: maxLen } = this.contextLimits();
         const modelContent = result.llmContent ?? result.output;
+        if (result.runtimeAuthored) {
+          const errPrefix = result.success ? "" : `Error: ${result.error || "runtime-authored tool feedback"}
+`;
+          return `${errPrefix}${modelContent}`;
+        }
         if (!result.success) {
           const errOutput = modelContent.length > maxLen ? this.foldOutput(modelContent, maxLen) : modelContent;
           return this.wrapToolOutputForModel(toolName, `Error: ${result.error || "unknown error"}
@@ -703376,12 +703532,24 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
       properties: {
         task: {
           type: "string",
-          description: "The task to delegate to the sub-agent"
+          description: "The task to delegate to the sub-agent. Prefer this key."
+        },
+        prompt: {
+          type: "string",
+          description: "Compatibility alias for task. Prefer task in new calls."
         },
         background: {
           type: "boolean",
           description: "Run in background (default: false). Returns task ID."
         },
+        run_in_background: {
+          type: "boolean",
+          description: "Compatibility alias for background. Prefer background in new calls."
+        },
+        subagent_type: {
+          type: "string",
+          description: "Compatibility hint only. sub_agent does not change tool permissions by type; use agent(prompt, subagent_type) for typed agents."
+        },
         max_turns: {
           type: "number",
           description: "Maximum turns for the sub-agent (default: 15). Use 0 to run until task_complete or timeout."
@@ -703391,14 +703559,35 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
           description: "If true, run with max_turns=0 so the sub-agent stops only at task_complete, abort, or timeout."
         }
       },
-      required: ["task"]
+      required: []
     },
     async execute(args) {
-      const task = String(args["task"] ?? "");
-      const background = Boolean(args["background"]);
+      const rawTask = args["task"] ?? args["prompt"] ?? args["message"] ?? args["query"] ?? "";
+      const task = String(rawTask);
+      const background = Boolean(
+        args["background"] ?? args["run_in_background"]
+      );
+      const compatibilityNotes = [];
+      if (args["task"] === void 0 && args["prompt"] !== void 0) {
+        compatibilityNotes.push("normalized prompt -> task");
+      }
+      if (args["background"] === void 0 && args["run_in_background"] !== void 0) {
+        compatibilityNotes.push("normalized run_in_background -> background");
+      }
+      if (args["subagent_type"] !== void 0) {
+        compatibilityNotes.push(
+          "sub_agent ignores subagent_type; use agent(prompt, subagent_type) when typed agent permissions matter"
+        );
+      }
+      const compatibilityPrefix = compatibilityNotes.length > 0 ? `Compatibility note: ${compatibilityNotes.join("; ")}.
+` : "";
       const maxTurns = args["until_task_complete"] === true ? 0 : typeof args["max_turns"] === "number" ? args["max_turns"] : 15;
       if (!task) {
-        return { success: false, output: "", error: "task is required" };
+        return {
+          success: false,
+          output: "",
+          error: "task is required; prompt is accepted as a compatibility alias"
+        };
       }
       const agentId = `sub-agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
       const cleanedLabelTask = cleanForStorage(task) || task;
@@ -703473,7 +703662,7 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
         );
         return {
           success: true,
-          output: `Sub-agent started in background: ${taskId}
+          output: `${compatibilityPrefix}Sub-agent started in background: ${taskId}
 Task: ${task}
 Use task_status(task_id="${taskId}") or task_output(task_id="${taskId}") to check progress.`
         };
@@ -703491,10 +703680,10 @@ Use task_status(task_id="${taskId}") or task_output(task_id="${taskId}") to chec
         if (onComplete) onComplete(agentId, task, 0, output2);
         return {
           success: true,
-          output: output2
+          output: `${compatibilityPrefix}${output2}`
         };
       }
-      const output = `Sub-agent did not complete after ${result.turns} turns, ${result.toolCalls} tool calls.`;
+      const output = `${compatibilityPrefix}Sub-agent did not complete after ${result.turns} turns, ${result.toolCalls} tool calls.`;
       if (onComplete) onComplete(agentId, task, 1, output);
       return {
         success: false,

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.303",
+  "version": "1.0.304",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.303",
+      "version": "1.0.304",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.303",
+  "version": "1.0.304",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",