@cosmicstack/mercury-agent 1.0.6 → 1.1.0

package/dist/index.js

@@ -1535,9 +1535,9 @@ var OpenAICompatProvider = class extends BaseProvider {
     });
     return {
       text: result.text,
-      inputTokens: result.usage?.promptTokens ?? 0,
-      outputTokens: result.usage?.completionTokens ?? 0,
-      totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+      inputTokens: result.usage?.inputTokens ?? 0,
+      outputTokens: result.usage?.outputTokens ?? 0,
+      totalTokens: (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0),
       model: this.model,
       provider: this.name
     };
@@ -1585,9 +1585,9 @@ var AnthropicProvider = class extends BaseProvider {
     });
     return {
       text: result.text,
-      inputTokens: result.usage?.promptTokens ?? 0,
-      outputTokens: result.usage?.completionTokens ?? 0,
-      totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+      inputTokens: result.usage?.inputTokens ?? 0,
+      outputTokens: result.usage?.outputTokens ?? 0,
+      totalTokens: (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0),
       model: this.model,
       provider: this.name
     };
@@ -1611,6 +1611,38 @@ var AnthropicProvider = class extends BaseProvider {
   }
 };
 
+// src/providers/deepseek.ts
+import { createDeepSeek } from "@ai-sdk/deepseek";
+var DeepSeekProvider = class extends BaseProvider {
+  name;
+  model;
+  modelInstance;
+  isReasoner;
+  constructor(config) {
+    super(config);
+    this.name = config.name;
+    this.model = config.model;
+    this.isReasoner = config.model === "deepseek-reasoner";
+    const client = createDeepSeek({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+    this.modelInstance = client(config.model);
+  }
+  async generateText(_prompt, _systemPrompt) {
+    throw new Error("Use getModelInstance() with the AI SDK agent loop");
+  }
+  async *streamText(_prompt, _systemPrompt) {
+    throw new Error("Use getModelInstance() with the AI SDK agent loop");
+  }
+  isAvailable() {
+    return this.config.apiKey.length > 0;
+  }
+  getModelInstance() {
+    return this.modelInstance;
+  }
+};
+
 // src/providers/ollama.ts
 import { createOllama } from "ollama-ai-provider";
 var OllamaProvider = class extends BaseProvider {
@@ -1668,6 +1700,8 @@ var ProviderRegistry = class {
         let provider;
         if (pc.name === "anthropic") {
           provider = new AnthropicProvider(pc);
+        } else if (pc.name === "deepseek") {
+          provider = new DeepSeekProvider(pc);
         } else if (pc.name === "ollamaCloud" || pc.name === "ollamaLocal") {
           provider = new OllamaProvider(pc);
         } else {
@@ -1720,7 +1754,7 @@ var ProviderRegistry = class {
 };
 
 // src/core/agent.ts
-import { generateText as generateText3, streamText as streamText3 } from "ai";
+import { generateText as generateText3, streamText as streamText3, stepCountIs } from "ai";
 
 // src/core/lifecycle.ts
 var VALID_TRANSITIONS = [
@@ -3885,6 +3919,7 @@ You can override this:
       }
       for (const provider of fallbackIterator) {
         try {
+          const deepseekProviderOptions = provider instanceof DeepSeekProvider && provider.isReasoner ? { deepseek: { thinking: { type: "enabled" } } } : void 0;
           logger.info({ provider: provider.name, model: provider.getModel(), steps: MAX_STEPS, stream: canStream }, "Generating agentic response");
           if (canStream && channel) {
             const streamResult = streamText3({
@@ -3892,8 +3927,9 @@ You can override this:
               system: systemPrompt,
               messages,
               tools: this.capabilities.getTools(),
-              maxSteps: MAX_STEPS,
+              stopWhen: stepCountIs(MAX_STEPS),
               abortSignal: loopAbortController.signal,
+              ...deepseekProviderOptions ? { providerOptions: deepseekProviderOptions } : {},
               onStepFinish: async ({ toolCalls, toolResults }) => {
                 if (toolCalls && toolResults && toolCalls.length > 0) {
                   const names = toolCalls.map((tc) => tc.toolName).join(", ");
@@ -3903,7 +3939,7 @@ You can override this:
                     const tr = toolResults[i];
                     const resultStr = typeof tr?.result === "string" ? tr.result : JSON.stringify(tr?.result ?? "");
                     const failed = resultStr.length < 5e3 && (resultStr.startsWith("Error:") || resultStr.startsWith("\u26A0") || resultStr.includes("exited with code") || resultStr.includes("Command failed") || resultStr.startsWith("Command exited with code"));
-                    loopDetector.record(tc.toolName, tc.args, failed);
+                    loopDetector.record(tc.toolName, tc.input, failed);
                   }
                   if (loopDetector.detectAbsoluteLimit()) {
                     logger.warn("Absolute tool call limit reached \u2014 aborting");
@@ -3961,7 +3997,7 @@ You can override this:
                   if (channel && msg.channelType !== "internal") {
                     if (channel instanceof CLIChannel) {
                       for (const tc of toolCalls) {
-                        await channel.sendToolFeedback(tc.toolName, tc.args).catch(() => {
+                        await channel.sendToolFeedback(tc.toolName, tc.input).catch(() => {
                         });
                       }
                       if (toolResults) {
@@ -3976,7 +4012,7 @@ You can override this:
                     } else if (channel instanceof TelegramChannel) {
                       const tgCh = channel;
                       for (const tc of toolCalls) {
-                        await tgCh.sendToolFeedback(tc.toolName, tc.args, msg.channelId).catch(() => {
+                        await tgCh.sendToolFeedback(tc.toolName, tc.input, msg.channelId).catch(() => {
                         });
                       }
                       if (toolResults) {
@@ -4042,7 +4078,8 @@ You can override this:
             const [usage] = await Promise.all([
               streamResult.usage
             ]);
-            result = { text: fullText, usage };
+            const streamReasoning = await streamResult.reasoning;
+            result = { text: fullText, usage, reasoning: streamReasoning };
             streamedText = fullText;
             loopDetector.recordStepText(fullText);
           } else {
@@ -4051,8 +4088,9 @@ You can override this:
               system: systemPrompt,
               messages,
               tools: this.capabilities.getTools(),
-              maxSteps: MAX_STEPS,
+              stopWhen: stepCountIs(MAX_STEPS),
               abortSignal: loopAbortController.signal,
+              ...deepseekProviderOptions ? { providerOptions: deepseekProviderOptions } : {},
               onStepFinish: async ({ toolCalls, toolResults }) => {
                 if (toolCalls && toolResults && toolCalls.length > 0) {
                   const names = toolCalls.map((tc) => tc.toolName).join(", ");
@@ -4062,7 +4100,7 @@ You can override this:
                     const tr = toolResults[i];
                     const resultStr = typeof tr?.result === "string" ? tr.result : JSON.stringify(tr?.result ?? "");
                     const failed = resultStr.length < 5e3 && (resultStr.startsWith("Error:") || resultStr.startsWith("\u26A0") || resultStr.includes("exited with code") || resultStr.includes("Command failed") || resultStr.startsWith("Command exited with code"));
-                    loopDetector.record(tc.toolName, tc.args, failed);
+                    loopDetector.record(tc.toolName, tc.input, failed);
                   }
                   if (loopDetector.detectAbsoluteLimit()) {
                     logger.warn("Absolute tool call limit reached \u2014 aborting");
@@ -4120,7 +4158,7 @@ You can override this:
                   if (channel && msg.channelType !== "internal") {
                     if (channel instanceof CLIChannel) {
                       for (const tc of toolCalls) {
-                        await channel.sendToolFeedback(tc.toolName, tc.args).catch(() => {
+                        await channel.sendToolFeedback(tc.toolName, tc.input).catch(() => {
                         });
                       }
                       if (toolResults) {
@@ -4135,7 +4173,7 @@ You can override this:
                     } else if (channel instanceof TelegramChannel) {
                       const tgCh = channel;
                       for (const tc of toolCalls) {
-                        await tgCh.sendToolFeedback(tc.toolName, tc.args, msg.channelId).catch(() => {
+                        await tgCh.sendToolFeedback(tc.toolName, tc.input, msg.channelId).catch(() => {
                         });
                       }
                       if (toolResults) {
@@ -4221,9 +4259,9 @@ You can override this:
       this.tokenBudget.recordUsage({
         provider: usedProvider.name,
         model: usedProvider.model,
-        inputTokens: result.usage?.promptTokens ?? 0,
-        outputTokens: result.usage?.completionTokens ?? 0,
-        totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+        inputTokens: result.usage?.inputTokens ?? 0,
+        outputTokens: result.usage?.outputTokens ?? 0,
+        totalTokens: (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0),
         channelType: msg.channelType
       });
       this.shortTerm.add(msg.channelId, {
@@ -4237,7 +4275,8 @@ You can override this:
         timestamp: Date.now(),
         role: "assistant",
         content: finalText,
-        tokenCount: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0)
+        tokenCount: (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0),
+        reasoning: result.reasoning || void 0
       });
       this.episodic.record({
         type: "message",
@@ -4433,14 +4472,14 @@ All actions auto-approved for this run.`,
           { role: "user", content: `User: ${userMessage}
 Assistant: ${agentResponse}` }
         ],
-        maxTokens: 400
+        maxOutputTokens: 400
       });
       this.tokenBudget.recordUsage({
         provider: provider.name,
         model: provider.getModel(),
-        inputTokens: result.usage?.promptTokens ?? 0,
-        outputTokens: result.usage?.completionTokens ?? 0,
-        totalTokens: (result.usage?.promptTokens ?? 0) + (result.usage?.completionTokens ?? 0),
+        inputTokens: result.usage?.inputTokens ?? 0,
+        outputTokens: result.usage?.outputTokens ?? 0,
+        totalTokens: (result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0),
         channelType: "internal"
       });
       const text = result.text.trim();
@@ -4537,6 +4576,11 @@ Or use /budget override, /budget reset, /budget set <number> anytime.`,
       await channel.send(ctx.manual(), channelId);
       return true;
     }
+    if (cmd === "/exit" || cmd === "/quit") {
+      await channel.send("Goodbye! Shutting down Mercury...", channelId);
+      this.shutdown();
+      return true;
+    }
     if (cmd === "/status") {
       const config = ctx.config();
       const budget = ctx.tokenBudget();
@@ -5842,16 +5886,16 @@ Allow access?`;
 };
 
 // src/capabilities/filesystem/read-file.ts
-import { tool } from "ai";
+import { tool, zodSchema } from "ai";
 import { z } from "zod";
 import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
 import { resolve as resolve4, isAbsolute } from "path";
 function createReadFileTool(permissions, getCwd) {
   return tool({
     description: "Read the contents of a file. The path must be within an allowed scope.",
-    parameters: z.object({
+    inputSchema: zodSchema(z.object({
       path: z.string().describe("Absolute or relative path to the file")
-    }),
+    })),
     execute: async ({ path: path3 }) => {
       const resolved = isAbsolute(path3) ? resolve4(path3) : resolve4(getCwd(), path3);
       const check = await permissions.checkFsAccess(resolved, "read");
@@ -5879,17 +5923,17 @@ function createReadFileTool(permissions, getCwd) {
 }
 
 // src/capabilities/filesystem/write-file.ts
-import { tool as tool2 } from "ai";
+import { tool as tool2, zodSchema as zodSchema2 } from "ai";
 import { z as z2 } from "zod";
 import { existsSync as existsSync9, writeFileSync as writeFileSync7 } from "fs";
 import { resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
 function createWriteFileTool(permissions, getCwd) {
   return tool2({
     description: "Write content to an existing file. The path must be within a writable scope.",
-    parameters: z2.object({
+    inputSchema: zodSchema2(z2.object({
       path: z2.string().describe("Absolute or relative path to the file"),
       content: z2.string().describe("The content to write to the file")
-    }),
+    })),
     execute: async ({ path: path3, content }) => {
       const resolved = isAbsolute2(path3) ? resolve5(path3) : resolve5(getCwd(), path3);
       const check = await permissions.checkFsAccess(resolved, "write");
@@ -5911,17 +5955,17 @@ function createWriteFileTool(permissions, getCwd) {
 }
 
 // src/capabilities/filesystem/create-file.ts
-import { tool as tool3 } from "ai";
+import { tool as tool3, zodSchema as zodSchema3 } from "ai";
 import { z as z3 } from "zod";
 import { existsSync as existsSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8 } from "fs";
 import { resolve as resolve6, dirname as dirname3, isAbsolute as isAbsolute3 } from "path";
 function createCreateFileTool(permissions, getCwd) {
   return tool3({
     description: "Create a new file with the given content. Also creates parent directories if needed. The path must be within a writable scope.",
-    parameters: z3.object({
+    inputSchema: zodSchema3(z3.object({
       path: z3.string().describe("Absolute or relative path for the new file"),
       content: z3.string().describe("The content of the new file")
-    }),
+    })),
     execute: async ({ path: path3, content }) => {
       const resolved = isAbsolute3(path3) ? resolve6(path3) : resolve6(getCwd(), path3);
       const check = await permissions.checkFsAccess(resolved, "write");
@@ -5947,16 +5991,16 @@ function createCreateFileTool(permissions, getCwd) {
 }
 
 // src/capabilities/filesystem/list-dir.ts
-import { tool as tool4 } from "ai";
+import { tool as tool4, zodSchema as zodSchema4 } from "ai";
 import { z as z4 } from "zod";
 import { existsSync as existsSync11, readdirSync as readdirSync2, statSync } from "fs";
 import { resolve as resolve7, isAbsolute as isAbsolute4, join as join9 } from "path";
 function createListDirTool(permissions, getCwd) {
   return tool4({
     description: "List the contents of a directory. Shows file names, types, and sizes.",
-    parameters: z4.object({
+    inputSchema: zodSchema4(z4.object({
       path: z4.string().describe("Absolute or relative path to the directory")
-    }),
+    })),
     execute: async ({ path: path3 }) => {
       const resolved = isAbsolute4(path3) ? resolve7(path3) : resolve7(getCwd(), path3);
       const check = await permissions.checkFsAccess(resolved, "read");
@@ -6002,16 +6046,16 @@ function formatSize(bytes) {
 }
 
 // src/capabilities/filesystem/delete-file.ts
-import { tool as tool5 } from "ai";
+import { tool as tool5, zodSchema as zodSchema5 } from "ai";
 import { z as z5 } from "zod";
 import { existsSync as existsSync12, unlinkSync as unlinkSync2 } from "fs";
 import { resolve as resolve8, isAbsolute as isAbsolute5 } from "path";
 function createDeleteFileTool(permissions, getCwd) {
   return tool5({
     description: "Delete a file. This action cannot be undone. The path must be within a writable scope. Always asks for confirmation.",
-    parameters: z5.object({
+    inputSchema: zodSchema5(z5.object({
       path: z5.string().describe("Absolute or relative path to the file to delete")
-    }),
+    })),
     execute: async ({ path: path3 }) => {
       const resolved = isAbsolute5(path3) ? resolve8(path3) : resolve8(getCwd(), path3);
       const check = await permissions.checkFsAccess(resolved, "write");
@@ -6037,18 +6081,18 @@ function createDeleteFileTool(permissions, getCwd) {
 }
 
 // src/capabilities/filesystem/edit-file.ts
-import { tool as tool6 } from "ai";
+import { tool as tool6, zodSchema as zodSchema6 } from "ai";
 import { z as z6 } from "zod";
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync9 } from "fs";
 import { resolve as resolve9, isAbsolute as isAbsolute6 } from "path";
 function createEditFileTool(permissions, getCwd) {
   return tool6({
     description: "Edit a file by replacing an exact string match with new content. Use this instead of write_file when you only need to change part of a file. The old_string must match exactly (including whitespace and indentation). Fails if old_string is not found or found multiple times.",
-    parameters: z6.object({
+    inputSchema: zodSchema6(z6.object({
       path: z6.string().describe("Absolute or relative path to the file"),
       old_string: z6.string().describe("The exact text to find in the file (must match exactly)"),
       new_string: z6.string().describe("The text to replace it with")
-    }),
+    })),
     execute: async ({ path: path3, old_string, new_string }) => {
       const resolved = isAbsolute6(path3) ? resolve9(path3) : resolve9(getCwd(), path3);
       const fsCheck = await permissions.checkFsAccess(resolved, "write");
@@ -6081,16 +6125,16 @@ function createEditFileTool(permissions, getCwd) {
 }
 
 // src/capabilities/filesystem/send-file.ts
-import { tool as tool7 } from "ai";
+import { tool as tool7, zodSchema as zodSchema7 } from "ai";
 import { z as z7 } from "zod";
 import { existsSync as existsSync13, statSync as statSync2 } from "fs";
 import { resolve as resolve10, basename as basename2, isAbsolute as isAbsolute7 } from "path";
 function createSendFileTool(permissions, getCwd, sendFile) {
   return tool7({
     description: "Send a file to the user. On Telegram the file is uploaded as an attachment to the relevant approved recipients. On CLI the file path and size are displayed. The path must be within an allowed read scope.",
-    parameters: z7.object({
+    inputSchema: zodSchema7(z7.object({
       path: z7.string().describe("Absolute or relative path to the file to send")
-    }),
+    })),
     execute: async ({ path: path3 }) => {
       const resolved = isAbsolute7(path3) ? resolve10(path3) : resolve10(getCwd(), path3);
       const check = await permissions.checkFsAccess(resolved, "read");
@@ -6121,14 +6165,14 @@ function createSendFileTool(permissions, getCwd, sendFile) {
 }
 
 // src/capabilities/messaging/send-message.ts
-import { tool as tool8 } from "ai";
+import { tool as tool8, zodSchema as zodSchema8 } from "ai";
 import { z as z8 } from "zod";
 function createSendMessageTool(sendMessage) {
   return tool8({
     description: "Send a message through the configured outbound channel. For Telegram this sends to the approved Telegram recipients. Use this only when the user explicitly asks you to send something to Telegram or asks for scheduled results to be sent there.",
-    parameters: z8.object({
+    inputSchema: zodSchema8(z8.object({
       content: z8.string().describe("The message content to send to the approved Telegram recipients")
-    }),
+    })),
     execute: async ({ content }) => {
       const trimmed = content.trim();
       if (!trimmed) {
@@ -6145,16 +6189,16 @@ function createSendMessageTool(sendMessage) {
 }
 
 // src/capabilities/filesystem/approve-scope.ts
-import { tool as tool9 } from "ai";
+import { tool as tool9, zodSchema as zodSchema9 } from "ai";
 import { z as z9 } from "zod";
 import { resolve as resolve11, isAbsolute as isAbsolute8 } from "path";
 function createApproveScopeTool(permissions, getCwd) {
   return tool9({
     description: 'Request user approval to access a directory outside current scopes. Use this when a file tool returns a permission denied error. The user gets an approval prompt (Allow/Always/Deny buttons on Telegram, yes/always/no on CLI). "Allow" grants session-only access. "Always" persists to disk. After approval, retry the original file operation.',
-    parameters: z9.object({
+    inputSchema: zodSchema9(z9.object({
       path: z9.string().describe("The directory path to request access to"),
       mode: z9.enum(["read", "write"]).describe("The access mode needed")
-    }),
+    })),
     execute: async ({ path: path3, mode }) => {
       const resolved = isAbsolute8(path3) ? resolve11(path3) : resolve11(getCwd(), path3);
       const result = await permissions.requestScopeExternal(resolved, mode);
@@ -6167,7 +6211,7 @@ function createApproveScopeTool(permissions, getCwd) {
 }
 
 // src/capabilities/shell/run-command.ts
-import { tool as tool10 } from "ai";
+import { tool as tool10, zodSchema as zodSchema10 } from "ai";
 import { z as z10 } from "zod";
 import { execSync } from "child_process";
 import { resolve as resolve12, isAbsolute as isAbsolute9 } from "path";
@@ -6179,9 +6223,9 @@ function createRunCommandTool(permissions, getCwd, setCwd) {
 Blocked commands (sudo, rm -rf /, etc.) are never executed.
 Auto-approved commands (ls, cat, git status, curl, etc.) run without asking.
 Other commands require user approval.`,
-    parameters: z10.object({
+    inputSchema: zodSchema10(z10.object({
       command: z10.string().describe("The shell command to execute")
-    }),
+    })),
     execute: async ({ command }) => {
       const check = await permissions.checkShellCommand(command);
       if (!check.allowed) {
@@ -6245,16 +6289,16 @@ function detectCd(command, currentCwd, setCwd) {
 }
 
 // src/capabilities/shell/cd.ts
-import { tool as tool11 } from "ai";
+import { tool as tool11, zodSchema as zodSchema11 } from "ai";
 import { z as z11 } from "zod";
 import { resolve as resolve13, isAbsolute as isAbsolute10 } from "path";
 import { existsSync as existsSync15, statSync as statSync3 } from "fs";
 function createCdTool(getCwd, setCwd) {
   return tool11({
     description: "Change the current working directory. All subsequent file operations, shell commands, and git operations will use this directory. Use this before running commands in a specific project folder.",
-    parameters: z11.object({
+    inputSchema: zodSchema11(z11.object({
       path: z11.string().describe("The directory to change to. Can be absolute or relative to the current directory.")
-    }),
+    })),
     execute: async ({ path: path3 }) => {
       const cwd = getCwd();
       const resolved = isAbsolute10(path3) ? resolve13(path3) : resolve13(cwd, path3);
@@ -6276,14 +6320,14 @@ function createCdTool(getCwd, setCwd) {
 }
 
 // src/capabilities/shell/approve-command.ts
-import { tool as tool12 } from "ai";
+import { tool as tool12, zodSchema as zodSchema12 } from "ai";
 import { z as z12 } from "zod";
 function createApproveCommandTool(permissions) {
   return tool12({
     description: 'Permanently approve a command type so it runs without asking in the future. Use this when the user says "always" or "always approve" for a command. For example, if the user says "always approve curl", call this with command="curl".',
-    parameters: z12.object({
+    inputSchema: zodSchema12(z12.object({
       command: z12.string().describe('The base command to permanently approve (e.g. "curl", "docker", "npm")')
-    }),
+    })),
     execute: async ({ command }) => {
       const baseCmd = command.trim().split(/\s+/)[0];
       permissions.addApprovedCommand(baseCmd);
@@ -6293,16 +6337,16 @@ function createApproveCommandTool(permissions) {
 }
 
 // src/capabilities/skills/install-skill.ts
-import { tool as tool13 } from "ai";
+import { tool as tool13, zodSchema as zodSchema13 } from "ai";
 import { z as z13 } from "zod";
 import { parse as parseYaml4 } from "yaml";
 function createInstallSkillTool(skillLoader) {
   return tool13({
     description: "Install a new skill by providing SKILL.md markdown content or a URL. The content must have YAML frontmatter (---) with at least name and description fields.",
-    parameters: z13.object({
+    inputSchema: zodSchema13(z13.object({
       content: z13.string().optional().describe("Raw SKILL.md markdown content with YAML frontmatter"),
       url: z13.string().optional().describe("URL to fetch a SKILL.md from")
-    }),
+    })),
     execute: async ({ content, url }) => {
       let skillContent;
       if (url && !content) {
@@ -6341,12 +6385,12 @@ function createInstallSkillTool(skillLoader) {
 }
 
 // src/capabilities/skills/list-skills.ts
-import { tool as tool14 } from "ai";
+import { tool as tool14, zodSchema as zodSchema14 } from "ai";
 import { z as z14 } from "zod";
 function createListSkillsTool(skillLoader) {
   return tool14({
     description: "List all installed skills with their names and descriptions.",
-    parameters: z14.object({}),
+    inputSchema: zodSchema14(z14.object({})),
     execute: async () => {
       const skills = skillLoader.getDiscovered();
       if (skills.length === 0) {
@@ -6358,14 +6402,14 @@ function createListSkillsTool(skillLoader) {
 }
 
 // src/capabilities/skills/use-skill.ts
-import { tool as tool15 } from "ai";
+import { tool as tool15, zodSchema as zodSchema15 } from "ai";
 import { z as z15 } from "zod";
 function createUseSkillTool(skillLoader, permissions) {
   return tool15({
     description: "Load and invoke a skill by name. Returns the skill's full instructions which should be followed as guidance for the current task.",
-    parameters: z15.object({
+    inputSchema: zodSchema15(z15.object({
       name: z15.string().describe("Name of the skill to invoke")
-    }),
+    })),
     execute: async ({ name }) => {
       const skill = skillLoader.load(name);
       if (!skill) {
@@ -6391,19 +6435,19 @@ Allowed tools: ${skill["allowed-tools"].join(", ")}`;
 }
 
 // src/capabilities/scheduler/schedule-task.ts
-import { tool as tool16 } from "ai";
+import { tool as tool16, zodSchema as zodSchema16 } from "ai";
 import { z as z16 } from "zod";
 import cron2 from "node-cron";
 function createScheduleTaskTool(scheduler, getContext) {
   return tool16({
     description: 'Schedule a task. Use "cron" for recurring tasks (e.g. "0 9 * * *" for daily at 9am) or "delay_seconds" for one-shot delayed tasks (e.g. 15 for "remind me in 15 seconds"). Provide exactly one of cron or delay_seconds.',
-    parameters: z16.object({
+    inputSchema: zodSchema16(z16.object({
       cron: z16.string().optional().describe('Cron expression for recurring tasks (e.g. "0 9 * * *" for daily at 9am)'),
       delay_seconds: z16.number().optional().describe('Delay in seconds for one-shot tasks (e.g. 15 for "remind me in 15 seconds")'),
       description: z16.string().describe("Human-readable description of what this task does"),
       prompt: z16.string().optional().describe("Prompt to send to the agent when the task fires"),
       skill_name: z16.string().optional().describe("Name of a skill to invoke when the task fires")
-    }),
+    })),
     execute: async ({ cron: cronExpr, delay_seconds, description, prompt, skill_name }) => {
       if (!cronExpr && !delay_seconds) {
         return "Either cron or delay_seconds must be provided.";
@@ -6455,12 +6499,12 @@ function createScheduleTaskTool(scheduler, getContext) {
 }
 
 // src/capabilities/scheduler/list-tasks.ts
-import { tool as tool17 } from "ai";
+import { tool as tool17, zodSchema as zodSchema17 } from "ai";
 import { z as z17 } from "zod";
 function createListTasksTool(scheduler) {
   return tool17({
     description: "List all scheduled tasks with their cron expressions and descriptions.",
-    parameters: z17.object({}),
+    inputSchema: zodSchema17(z17.object({})),
     execute: async () => {
       const manifests = scheduler.getManifests();
       if (manifests.length === 0) {
@@ -6475,14 +6519,14 @@ function createListTasksTool(scheduler) {
 }
 
 // src/capabilities/scheduler/cancel-task.ts
-import { tool as tool18 } from "ai";
+import { tool as tool18, zodSchema as zodSchema18 } from "ai";
 import { z as z18 } from "zod";
 function createCancelTaskTool(scheduler) {
   return tool18({
     description: "Cancel and remove a scheduled task by its ID.",
-    parameters: z18.object({
+    inputSchema: zodSchema18(z18.object({
       id: z18.string().describe("ID of the scheduled task to cancel")
-    }),
+    })),
     execute: async ({ id }) => {
       const manifests = scheduler.getManifests();
       const exists = manifests.some((m) => m.id === id);
@@ -6497,12 +6541,12 @@ function createCancelTaskTool(scheduler) {
 }
 
 // src/capabilities/system/budget-status.ts
-import { tool as tool19 } from "ai";
+import { tool as tool19, zodSchema as zodSchema19 } from "ai";
 import { z as z19 } from "zod";
 function createBudgetStatusTool(tokenBudget) {
   return tool19({
     description: "Check the current token budget status \u2014 how many tokens have been used today, how many remain, and what percentage is consumed.",
-    parameters: z19.object({}),
+    inputSchema: zodSchema19(z19.object({})),
     execute: async () => {
       return tokenBudget.getStatusText();
     }
@@ -6510,15 +6554,15 @@ function createBudgetStatusTool(tokenBudget) {
 }
 
 // src/capabilities/git/git-status.ts
-import { tool as tool20 } from "ai";
+import { tool as tool20, zodSchema as zodSchema20 } from "ai";
 import { z as z20 } from "zod";
 import { execSync as execSync2 } from "child_process";
 function createGitStatusTool(getCwd) {
   return tool20({
     description: "Show the working tree status. Returns staged, unstaged, and untracked files.",
-    parameters: z20.object({
+    inputSchema: zodSchema20(z20.object({
       path: z20.string().optional().describe("Path to check (defaults to current directory)")
-    }),
+    })),
     execute: async ({ path: path3 }) => {
       try {
         const cmd = path3 ? `git -C "${path3}" status --porcelain` : "git status --porcelain";
@@ -6533,16 +6577,16 @@ function createGitStatusTool(getCwd) {
 }
 
 // src/capabilities/git/git-diff.ts
-import { tool as tool21 } from "ai";
+import { tool as tool21, zodSchema as zodSchema21 } from "ai";
 import { z as z21 } from "zod";
 import { execSync as execSync3 } from "child_process";
 function createGitDiffTool(getCwd) {
   return tool21({
     description: "Show changes between commits, commit and working tree, etc. Shows what has been modified.",
-    parameters: z21.object({
+    inputSchema: zodSchema21(z21.object({
       path: z21.string().optional().describe("File or directory to diff"),
       staged: z21.boolean().optional().describe("Show staged changes (cached) instead of unstaged")
-    }),
+    })),
     execute: async ({ path: path3, staged }) => {
       try {
         let cmd = "git diff";
@@ -6560,16 +6604,16 @@ function createGitDiffTool(getCwd) {
 }
 
 // src/capabilities/git/git-log.ts
-import { tool as tool22 } from "ai";
+import { tool as tool22, zodSchema as zodSchema22 } from "ai";
 import { z as z22 } from "zod";
 import { execSync as execSync4 } from "child_process";
 function createGitLogTool(getCwd) {
   return tool22({
     description: "Show commit logs. Returns recent commit history with hash, author, date, and message.",
-    parameters: z22.object({
+    inputSchema: zodSchema22(z22.object({
       count: z22.number().optional().describe("Number of commits to show (default 10)"),
       path: z22.string().optional().describe("File or directory to show log for")
-    }),
+    })),
     execute: async ({ count, path: path3 }) => {
       try {
         const n = count ?? 10;
@@ -6586,15 +6630,15 @@ function createGitLogTool(getCwd) {
 }
 
 // src/capabilities/git/git-add.ts
-import { tool as tool23 } from "ai";
+import { tool as tool23, zodSchema as zodSchema23 } from "ai";
 import { z as z23 } from "zod";
 import { execSync as execSync5 } from "child_process";
 function createGitAddTool(getCwd) {
   return tool23({
     description: "Add file contents to the index (staging area). Prepares files for commit.",
-    parameters: z23.object({
+    inputSchema: zodSchema23(z23.object({
       paths: z23.array(z23.string()).describe("File paths to stage")
-    }),
+    })),
     execute: async ({ paths }) => {
       try {
         const fileArgs = paths.map((p) => `"${p}"`).join(" ");
@@ -6608,7 +6652,7 @@ function createGitAddTool(getCwd) {
 }
 
 // src/capabilities/git/git-commit.ts
-import { tool as tool24 } from "ai";
+import { tool as tool24, zodSchema as zodSchema24 } from "ai";
 import { z as z24 } from "zod";
 import { execSync as execSync6 } from "child_process";
 import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync3 } from "fs";
@@ -6617,9 +6661,9 @@ var CO_AUTHOR = "Mercury <mercury@cosmicstack.org>";
 function createGitCommitTool(getCwd) {
   return tool24({
     description: "Record changes to the repository. Creates a new commit with staged changes. Automatically includes a Co-authored-by trailer for attribution.",
-    parameters: z24.object({
+    inputSchema: zodSchema24(z24.object({
       message: z24.string().describe("Commit message")
-    }),
+    })),
     execute: async ({ message }) => {
       try {
         const fullMessage = `${message}
@@ -6654,16 +6698,16 @@ Co-authored-by: ${CO_AUTHOR}`;
 }
 
 // src/capabilities/git/git-push.ts
-import { tool as tool25 } from "ai";
+import { tool as tool25, zodSchema as zodSchema25 } from "ai";
 import { z as z25 } from "zod";
 import { execSync as execSync7 } from "child_process";
 function createGitPushTool(permissions, getCwd) {
   return tool25({
     description: "Push commits to a remote repository. This modifies a remote and requires approval.",
-    parameters: z25.object({
+    inputSchema: zodSchema25(z25.object({
       remote: z25.string().optional().describe("Remote name (default: origin)"),
       branch: z25.string().optional().describe("Branch name (default: current branch)")
-    }),
+    })),
     execute: async ({ remote, branch }) => {
       const cmd = `git push ${remote || "origin"} ${branch || ""}`.trim();
       const check = await permissions.checkShellCommand(cmd);
@@ -6687,7 +6731,7 @@ Ask the user for permission. If they approve, try again. If they say "always", u
 }
 
 // src/capabilities/github/create-pr.ts
-import { tool as tool26 } from "ai";
+import { tool as tool26, zodSchema as zodSchema26 } from "ai";
 import { z as z26 } from "zod";
 
 // src/utils/github.ts
@@ -6745,7 +6789,7 @@ async function githubRequest(path3, options = {}) {
 function createCreatePrTool() {
   return tool26({
     description: "Create a pull request on GitHub. Requires GITHUB_TOKEN to be configured.",
-    parameters: z26.object({
+    inputSchema: zodSchema26(z26.object({
       owner: z26.string().describe("Repository owner (username or org)"),
       repo: z26.string().describe("Repository name"),
       title: z26.string().describe("PR title"),
@@ -6753,7 +6797,7 @@ function createCreatePrTool() {
       head: z26.string().describe("The branch containing the changes"),
       base: z26.string().describe("The branch to merge into").default("main"),
       draft: z26.boolean().describe("Create as draft PR").default(false)
-    }),
+    })),
     execute: async ({ owner, repo, title, body, head, base, draft }) => {
       try {
         const result = await githubRequest(`/repos/${owner}/${repo}/pulls`, {
@@ -6771,17 +6815,17 @@ ${draft ? "(draft)" : ""} ${result.state}`;
 }
 
 // src/capabilities/github/review-pr.ts
-import { tool as tool27 } from "ai";
+import { tool as tool27, zodSchema as zodSchema27 } from "ai";
 import { z as z27 } from "zod";
 function createReviewPrTool() {
   return tool27({
     description: "Get details of a pull request including the diff. Reviews the PR and returns the title, body, changed files, and diff. Optionally post a review comment.",
-    parameters: z27.object({
+    inputSchema: zodSchema27(z27.object({
       owner: z27.string().describe("Repository owner (username or org)"),
       repo: z27.string().describe("Repository name"),
       number: z27.number().describe("PR number"),
       comment: z27.string().describe("Review comment to post on the PR (optional)").optional()
-    }),
+    })),
     execute: async ({ owner, repo, number, comment }) => {
       try {
         const pr = await githubRequest(`/repos/${owner}/${repo}/pulls/${number}`);
@@ -6846,18 +6890,18 @@ Failed to post review comment: ${err.message}`;
 }
 
 // src/capabilities/github/list-issues.ts
-import { tool as tool28 } from "ai";
+import { tool as tool28, zodSchema as zodSchema28 } from "ai";
 import { z as z28 } from "zod";
 function createListIssuesTool() {
   return tool28({
     description: "List GitHub issues for a repository. Requires GITHUB_TOKEN.",
-    parameters: z28.object({
+    inputSchema: zodSchema28(z28.object({
       owner: z28.string().describe("Repository owner (username or org)"),
       repo: z28.string().describe("Repository name"),
       state: z28.enum(["open", "closed", "all"]).describe("Filter by issue state").default("open"),
       labels: z28.string().describe("Comma-separated label names to filter by (optional)").optional(),
       limit: z28.number().describe("Maximum number of issues to return").default(10)
-    }),
+    })),
     execute: async ({ owner, repo, state, labels, limit }) => {
       try {
         const params = new URLSearchParams();
@@ -6884,18 +6928,18 @@ ${lines.join("\n")}`;
 }
 
 // src/capabilities/github/create-issue.ts
-import { tool as tool29 } from "ai";
+import { tool as tool29, zodSchema as zodSchema29 } from "ai";
 import { z as z29 } from "zod";
 function createCreateIssueTool() {
   return tool29({
     description: "Create a new GitHub issue in a repository. Requires GITHUB_TOKEN.",
-    parameters: z29.object({
+    inputSchema: zodSchema29(z29.object({
       owner: z29.string().describe("Repository owner (username or org)"),
       repo: z29.string().describe("Repository name"),
       title: z29.string().describe("Issue title"),
       body: z29.string().describe("Issue description (markdown supported)").default(""),
       labels: z29.array(z29.string()).describe("Label names to apply").optional()
-    }),
+    })),
     execute: async ({ owner, repo, title, body, labels }) => {
       try {
         const payload = { title, body };
@@ -6914,7 +6958,7 @@ function createCreateIssueTool() {
 }
 
 // src/capabilities/github/github-api.ts
-import { tool as tool30 } from "ai";
+import { tool as tool30, zodSchema as zodSchema30 } from "ai";
 import { z as z30 } from "zod";
 var CO_AUTHOR_NAME = "Mercury";
 var CO_AUTHOR_EMAIL = "mercury@cosmicstack.org";
@@ -6950,11 +6994,11 @@ Common operations you can perform:
 - Any other GitHub API v3 endpoint.
 
 IMPORTANT: When the user wants to push code or files to GitHub and git push fails (auth issues, no SSH key, etc.), use PUT /repos/{owner}/{repo}/contents/{path} to create or update files directly through the API. This bypasses local git and creates a commit with Mercury as co-author.`,
-    parameters: z30.object({
+    inputSchema: zodSchema30(z30.object({
       path: z30.string().describe("Full API path (e.g., /repos/owner/repo/issues or /repos/owner/repo/contents/path/to/file)"),
       method: z30.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]).describe("HTTP method").default("GET"),
       body: z30.string().describe("JSON body for write requests (as a JSON string)").optional()
-    }),
+    })),
     execute: async ({ path: path3, method, body }) => {
       try {
         let parsedBody;
@@ -6983,7 +7027,7 @@ IMPORTANT: When the user wants to push code or files to GitHub and git push fail
 }
 
 // src/capabilities/web/fetch-url.ts
-import { tool as tool31 } from "ai";
+import { tool as tool31, zodSchema as zodSchema31 } from "ai";
 import { z as z31 } from "zod";
 var MAX_CONTENT_LENGTH = 15e3;
 function stripHtml(html) {
@@ -7019,10 +7063,10 @@ function stripHtml(html) {
 function createFetchUrlTool() {
   return tool31({
     description: "Fetch a URL and return its content as text. Strips HTML to readable markdown-like format. Useful for reading documentation, APIs, or web pages.",
-    parameters: z31.object({
+    inputSchema: zodSchema31(z31.object({
       url: z31.string().describe("The URL to fetch"),
       format: z31.enum(["text", "markdown"]).optional().describe("Output format (default: markdown)")
-    }),
+    })),
     execute: async ({ url, format }) => {
       const outputFormat = format ?? "markdown";
       try {