@arii/boomtick-mcp 0.4.0 → 0.4.2

package/.mcp/schemas/repo_run_lighthouse.json

@@ -0,0 +1,29 @@
+{
+  "name": "repo_run_lighthouse",
+  "description": "Run Lighthouse CI audits.",
+  "parameters": {
+    "properties": {
+      "route": {
+        "default": "/",
+        "description": "The route to audit (default: '/').",
+        "title": "Route",
+        "type": "string"
+      },
+      "worktreePath": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "description": "Optional path to the worktree to run the audit in.",
+        "title": "Worktreepath"
+      }
+    },
+    "title": "RunLighthouseInput",
+    "type": "object"
+  }
+}

package/.mcp/schemas/repo_run_playwright.json

@@ -0,0 +1,36 @@
+{
+  "name": "repo_run_playwright",
+  "description": "Run Playwright E2E tests.",
+  "parameters": {
+    "properties": {
+      "grep": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "description": "Optional pattern to filter tests by name.",
+        "title": "Grep"
+      },
+      "worktreePath": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "description": "Optional path to the worktree to run tests in.",
+        "title": "Worktreepath"
+      }
+    },
+    "title": "RunPlaywrightInput",
+    "type": "object"
+  }
+}

package/.mcp/schemas/repo_run_tests.json

@@ -0,0 +1,45 @@
+{
+  "name": "repo_run_tests",
+  "description": "Run repository tests and checks.",
+  "parameters": {
+    "properties": {
+      "commands": {
+        "anyOf": [
+          {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "description": "Optional list of commands to run (default includes install, lint, test, build).",
+        "title": "Commands"
+      },
+      "timeoutSeconds": {
+        "default": 300,
+        "description": "Maximum time in seconds to wait for tests (default: 300).",
+        "title": "Timeoutseconds",
+        "type": "integer"
+      },
+      "worktreePath": {
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ],
+        "default": null,
+        "description": "Optional path to the worktree to run tests in.",
+        "title": "Worktreepath"
+      }
+    },
+    "title": "RunTestsInput",
+    "type": "object"
+  }
+}

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.4.2](https://github.com/arii/boomtick/compare/mcp-v0.4.1...mcp-v0.4.2) (2026-10-12)
+
+
+### Bug Fixes
+
+* **mcp:** map tool JSON Schema to parameters object in sync-mcp-schemas ([#802](https://github.com/arii/boomtick/issues/802)) ([a57a9ae](https://github.com/arii/boomtick/commit/a57a9aef32109242882d682fcbd1a9ff0a81cffe))
+* **mcp:** resolve identifier regex, commit patch, timeout, and parameter casing bugs ([#815](https://github.com/arii/boomtick/issues/815)) ([1f3b232](https://github.com/arii/boomtick/commit/1f3b232d8550fa87eac2dd974bfd67252a8f4da1))
+* **mcp:** support dynamic repo context resolution and --repo forwarding across workspaces ([#811](https://github.com/arii/boomtick/issues/811)) ([f7e1665](https://github.com/arii/boomtick/commit/f7e166594f170843b7f2e267fab119c631bf3c83))
+
+## [0.4.1](https://github.com/arii/boomtick/compare/mcp-v0.4.0...mcp-v0.4.1) (2026-09-22)
+
+
+### Bug Fixes
+
+* **cli,mcp:** improve workspace config resolution and github repo detection ([#787](https://github.com/arii/boomtick/issues/787)) ([0103e90](https://github.com/arii/boomtick/commit/0103e904d30213cc336a1ce9567ad59257494236))
+
 ## [0.4.0](https://github.com/arii/boomtick/compare/mcp-v0.3.7...mcp-v0.4.0) (2026-09-04)
 
 

package/dist/config.js

@@ -1,13 +1,17 @@
-import dotenv from "dotenv";
 import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
 import { execSync } from "child_process";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-dotenv.config({
-    path: path.resolve(__dirname, "../.env"),
-    quiet: true
-});
+const envPath = path.resolve(__dirname, "../.env");
+if (fs.existsSync(envPath) && typeof process.loadEnvFile === "function") {
+    try {
+        process.loadEnvFile(envPath);
+    }
+    catch {
+        // Ignore if already loaded or invalid
+    }
+}
 function getGithubToken() {
     if (process.env.GITHUB_TOKEN) {
         return process.env.GITHUB_TOKEN;
@@ -31,9 +35,11 @@ export function initializeConfig() {
         return cachedDynamicConfig;
     }
     try {
-        // Attempt to load core properties from the Python CLI to avoid duplication
+        // Attempt to load core properties from the Python CLI in the active workspace
+        const cwd = process.env.BOOMTICK_REPO_PATH || process.cwd();
         const cmd = `td-cli config view`;
         const output = execSync(cmd, {
+            cwd,
             encoding: "utf-8",
             stdio: ["ignore", "pipe", "ignore"]
         });
@@ -58,10 +64,22 @@ function findRepoRoot() {
     if (process.env.BOOMTICK_REPO_PATH) {
         return process.env.BOOMTICK_REPO_PATH;
     }
-    // Traverse up to find workspace.json or .git
-    let current = __dirname;
+    // Traverse up from process.cwd() to find project_config.json, workspace.json, or .git
+    let current = process.cwd();
     while (current !== path.parse(current).root) {
-        if (fs.existsSync(path.join(current, "workspace.json")) || fs.existsSync(path.join(current, ".git"))) {
+        if (fs.existsSync(path.join(current, "project_config.json")) ||
+            fs.existsSync(path.join(current, "workspace.json")) ||
+            fs.existsSync(path.join(current, ".git"))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    // Fallback to __dirname search if discovery from cwd fails
+    current = __dirname;
+    while (current !== path.parse(current).root) {
+        if (fs.existsSync(path.join(current, "project_config.json")) ||
+            fs.existsSync(path.join(current, "workspace.json")) ||
+            fs.existsSync(path.join(current, ".git"))) {
             return current;
         }
         current = path.dirname(current);
@@ -72,22 +90,30 @@ function findRepoRoot() {
 export const config = {
     get githubToken() { return getGithubToken(); },
     get githubOwner() {
+        const repoString = cachedDynamicConfig?.github_repo;
+        if (typeof repoString === "string" && repoString.includes("/")) {
+            return repoString.split("/")[0];
+        }
         if (process.env.GITHUB_OWNER)
             return process.env.GITHUB_OWNER;
-        const repoString = cachedDynamicConfig?.github_repo;
-        if (typeof repoString !== "string" || !repoString.includes("/")) {
-            throw new Error("GITHUB_OWNER must be set via environment variable or project_config.json");
+        const envRepo = process.env.GITHUB_REPOSITORY || process.env.GH_REPO;
+        if (envRepo && envRepo.includes("/")) {
+            return envRepo.split("/")[0];
         }
-        return repoString.split("/")[0];
+        throw new Error("GITHUB_OWNER must be set via environment variable or project_config.json");
     },
     get githubRepo() {
+        const repoString = cachedDynamicConfig?.github_repo;
+        if (typeof repoString === "string" && repoString.includes("/")) {
+            return repoString.split("/")[1];
+        }
         if (process.env.GITHUB_REPO)
             return process.env.GITHUB_REPO;
-        const repoString = cachedDynamicConfig?.github_repo;
-        if (typeof repoString !== "string" || !repoString.includes("/")) {
-            throw new Error("GITHUB_REPO must be set via environment variable or project_config.json");
+        const envRepo = process.env.GITHUB_REPOSITORY || process.env.GH_REPO;
+        if (envRepo && envRepo.includes("/")) {
+            return envRepo.split("/")[1];
         }
-        return repoString.split("/")[1];
+        throw new Error("GITHUB_REPO must be set via environment variable or project_config.json");
     },
     get repoPath() {
         return findRepoRoot();

package/dist/config.test.js

@@ -15,12 +15,14 @@ describe("config", () => {
         process.env = originalEnv;
     });
     describe("initializeConfig", () => {
-        it("should load dynamic config from td-cli config view", async () => {
+        it("should load dynamic config from td-cli config view using active cwd", async () => {
             const mockConfig = { github_repo: "owner/repo", base_branch: "origin/main", vite_base_path: "/app/" };
             vi.mocked(execSync).mockReturnValue(JSON.stringify(mockConfig));
             const { initializeConfig } = await import("./config.js");
             const result = initializeConfig();
-            expect(execSync).toHaveBeenCalledWith("td-cli config view", expect.anything());
+            expect(execSync).toHaveBeenCalledWith("td-cli config view", expect.objectContaining({
+                cwd: process.cwd()
+            }));
             expect(result).toEqual(mockConfig);
         });
         it("should return cached dynamic config on subsequent calls", async () => {
@@ -67,7 +69,18 @@ describe("config", () => {
             });
             expect(config.githubToken).toBeUndefined();
         });
-        it("should resolve githubOwner and githubRepo from env or cached config", async () => {
+        it("should prioritize cachedDynamicConfig over environment variables for githubOwner and githubRepo", async () => {
+            process.env.GITHUB_OWNER = "env-owner";
+            process.env.GITHUB_REPO = "env-repo";
+            process.env.GITHUB_REPOSITORY = "env-owner/env-repo";
+            const mockConfig = { github_repo: "workspace-owner/workspace-repo" };
+            vi.mocked(execSync).mockReturnValue(JSON.stringify(mockConfig));
+            const { config, initializeConfig } = await import("./config.js");
+            initializeConfig();
+            expect(config.githubOwner).toBe("workspace-owner");
+            expect(config.githubRepo).toBe("workspace-repo");
+        });
+        it("should fallback to environment variables when cachedDynamicConfig is empty", async () => {
             process.env.GITHUB_OWNER = "custom-owner";
             process.env.GITHUB_REPO = "custom-repo";
             const { config } = await import("./config.js");
@@ -77,6 +90,8 @@ describe("config", () => {
         it("should throw when githubOwner / githubRepo cannot be determined", async () => {
             delete process.env.GITHUB_OWNER;
             delete process.env.GITHUB_REPO;
+            delete process.env.GITHUB_REPOSITORY;
+            delete process.env.GH_REPO;
             vi.mocked(execSync).mockImplementation(() => {
                 throw new Error("td-cli failed");
             });

package/dist/lib/git.js

@@ -1,6 +1,36 @@
 import { runCommand } from "./shell.js";
+import { config } from "../config.js";
 import path from "path";
 import fs from "fs/promises";
+import { execSync } from "child_process";
+const repoCache = new Map();
+export function resolveRepo(explicitRepo, cwd) {
+    if (explicitRepo && explicitRepo.trim().length > 0) {
+        return explicitRepo.trim();
+    }
+    const targetCwd = cwd || process.cwd();
+    if (repoCache.has(targetCwd)) {
+        return repoCache.get(targetCwd);
+    }
+    try {
+        const url = execSync("git remote get-url origin", {
+            cwd: targetCwd,
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        const match = url.match(/[:/]([^/]+\/[^/.]+)(\.git)?$/);
+        if (match) {
+            repoCache.set(targetCwd, match[1]);
+            return match[1];
+        }
+    }
+    catch (e) {
+        // Ignore error and fall back to static config
+    }
+    const fallback = `${config.githubOwner}/${config.githubRepo}`;
+    repoCache.set(targetCwd, fallback);
+    return fallback;
+}
 function validatePrNumber(value) {
     const prNumber = Number(value);
     if (!Number.isInteger(prNumber) || prNumber <= 0) {

package/dist/lib/param_utils.js

@@ -0,0 +1,35 @@
+export function normalizeArguments(args) {
+    if (!args || typeof args !== "object") {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(args)) {
+        // Convert snake_case to camelCase
+        const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        // Normalize value recursively if it's an object/array
+        let normalizedValue = value;
+        if (Array.isArray(value)) {
+            normalizedValue = value.map((item) => item && typeof item === "object" ? normalizeArguments(item) : item);
+        }
+        else if (value && typeof value === "object" && !(value instanceof RegExp)) {
+            normalizedValue = normalizeArguments(value);
+        }
+        // Coerce numeric string to integer for prNumber / issueNumber if applicable
+        if ((camelKey === "prNumber" || camelKey === "issueNumber") && typeof normalizedValue === "string") {
+            const parsedNum = parseInt(normalizedValue, 10);
+            if (!isNaN(parsedNum)) {
+                normalizedValue = parsedNum;
+            }
+        }
+        result[camelKey] = normalizedValue;
+    }
+    // Parameter aliases harmonization
+    // branch vs branchName harmonization
+    if (result.branch !== undefined && result.branchName === undefined) {
+        result.branchName = result.branch;
+    }
+    else if (result.branchName !== undefined && result.branch === undefined) {
+        result.branch = result.branchName;
+    }
+    return result;
+}

package/dist/lib/param_utils.test.js

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "vitest";
+import { normalizeArguments } from "./param_utils.js";
+describe("param_utils.normalizeArguments", () => {
+    it("should convert snake_case keys to camelCase", () => {
+        const input = {
+            pr_number: 123,
+            issue_number: 456,
+            worktree_path: "/tmp/worktree",
+            base_branch: "main",
+        };
+        const output = normalizeArguments(input);
+        expect(output).toEqual({
+            prNumber: 123,
+            issueNumber: 456,
+            worktreePath: "/tmp/worktree",
+            baseBranch: "main",
+        });
+    });
+    it("should coerce numeric strings for prNumber and issueNumber", () => {
+        const input = {
+            pr_number: "789",
+            issue_number: "101",
+        };
+        const output = normalizeArguments(input);
+        expect(output).toEqual({
+            prNumber: 789,
+            issueNumber: 101,
+        });
+    });
+    it("should synchronize branch and branchName", () => {
+        expect(normalizeArguments({ branch: "feat-x" })).toEqual({
+            branch: "feat-x",
+            branchName: "feat-x",
+        });
+        expect(normalizeArguments({ branch_name: "feat-y" })).toEqual({
+            branchName: "feat-y",
+            branch: "feat-y",
+        });
+    });
+    it("should handle null or empty arguments safely", () => {
+        expect(normalizeArguments(null)).toEqual({});
+        expect(normalizeArguments(undefined)).toEqual({});
+    });
+});

package/dist/mcp/definitions.js

@@ -63,7 +63,7 @@ export const MCP_RESOURCES = [
         description: "Playwright test report for a specific branch.",
     },
 ];
-export const MCP_TOOLS = [
+const BASE_MCP_TOOLS = [
     {
         name: "boomtick.health",
         description: "Check the health and configuration of the MCP server.",
@@ -240,3 +240,13 @@ export const MCP_TOOLS = [
         inputSchema: SearchDdgsInputJsonSchema,
     },
 ];
+export const MCP_TOOLS = BASE_MCP_TOOLS.flatMap((tool) => {
+    const underscoreName = tool.name.replace(/\./g, "_");
+    if (underscoreName !== tool.name) {
+        return [
+            { ...tool, name: underscoreName },
+            tool,
+        ];
+    }
+    return [tool];
+});

package/dist/mcp/schemas.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+describe("MCP tool schemas export", () => {
+    it("should generate valid schema files with non-null parameters object", () => {
+        const schemasDir = path.resolve(process.cwd(), ".mcp/schemas");
+        if (!fs.existsSync(schemasDir)) {
+            execSync("npx tsx scripts/sync-mcp-schemas.ts", { cwd: process.cwd() });
+        }
+        expect(fs.existsSync(schemasDir)).toBe(true);
+        const files = fs.readdirSync(schemasDir).filter((f) => f.endsWith(".json"));
+        expect(files.length).toBeGreaterThan(0);
+        for (const file of files) {
+            const filePath = path.join(schemasDir, file);
+            const content = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            expect(content).toHaveProperty("name");
+            expect(typeof content.name).toBe("string");
+            expect(content).toHaveProperty("description");
+            expect(typeof content.description).toBe("string");
+            expect(content).toHaveProperty("parameters");
+            expect(content.parameters).not.toBeNull();
+            expect(typeof content.parameters).toBe("object");
+            expect(content.parameters.type).toBe("object");
+            expect(content.parameters.properties).toBeDefined();
+        }
+    });
+});

package/dist/mcp/server.js

@@ -4,6 +4,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSche
 import { config } from "../config.js";
 import { createSuccessResult, createErrorResult } from "../lib/result.js";
 import { MCP_TOOLS, MCP_PROMPTS, MCP_RESOURCES } from "./definitions.js";
+import { normalizeArguments } from "../lib/param_utils.js";
 import { healthHandler, HealthCheckInputSchema } from "./tools.js";
 import { searchOpenPrsHandler, SearchOpenPrsInputSchema } from "../tools/github.search_open_prs.js";
 import { getPrDiffHandler, GetPrDiffInputSchema } from "../tools/github.get_pr_diff.js";
@@ -157,77 +158,112 @@ export class BoomtickMCPServer {
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
-                switch (request.params.name) {
+                const normalizedToolName = request.params.name.replace(/_/g, ".");
+                const normArgs = normalizeArguments(request.params.arguments);
+                switch (normalizedToolName) {
                     case "boomtick.health":
-                        return createSuccessResult(await healthHandler(HealthCheckInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await healthHandler(HealthCheckInputSchema.parse(normArgs)));
+                    case "github.search.open.prs":
                     case "github.search_open_prs":
-                        return createSuccessResult(await searchOpenPrsHandler(SearchOpenPrsInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await searchOpenPrsHandler(SearchOpenPrsInputSchema.parse(normArgs)));
+                    case "repo.read.agent.context":
                     case "repo.read_agent_context":
-                        return createSuccessResult(await readAgentContextHandler(ReadAgentContextInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await readAgentContextHandler(ReadAgentContextInputSchema.parse(normArgs)));
+                    case "github.get.pr.diff":
                     case "github.get_pr_diff":
-                        return createSuccessResult(await getPrDiffHandler(GetPrDiffInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getPrDiffHandler(GetPrDiffInputSchema.parse(normArgs)));
+                    case "github.get.merge.conflict.files":
                     case "github.get_merge_conflict_files":
-                        return createSuccessResult(await getMergeConflictFilesHandler(GetMergeConflictFilesInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getMergeConflictFilesHandler(GetMergeConflictFilesInputSchema.parse(normArgs)));
+                    case "github.checkout.branch":
                     case "github.checkout_branch":
-                        return createSuccessResult(await checkoutBranchHandler(CheckoutBranchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await checkoutBranchHandler(CheckoutBranchInputSchema.parse(normArgs)));
+                    case "repo.get.changed.files":
                     case "repo.get_changed_files":
-                        return createSuccessResult(await getChangedFilesHandler(GetChangedFilesInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await getChangedFilesHandler(GetChangedFilesInputSchema.parse(normArgs)));
+                    case "repo.get.command.schema":
                     case "repo.get_command_schema":
-                        return createSuccessResult(await getCommandSchemaHandler(GetCommandSchemaInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getCommandSchemaHandler(GetCommandSchemaInputSchema.parse(normArgs)));
+                    case "repo.get.package.scripts":
                     case "repo.get_package_scripts":
-                        return createSuccessResult(await getPackageScriptsHandler(GetPackageScriptsInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await getPackageScriptsHandler(GetPackageScriptsInputSchema.parse(normArgs)));
+                    case "repo.get.route.map":
                     case "repo.get_route_map":
-                        return createSuccessResult(await getRouteMapHandler(GetRouteMapInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await getRouteMapHandler(GetRouteMapInputSchema.parse(normArgs)));
+                    case "repo.read.ci.logs":
                     case "repo.read_ci_logs":
-                        return createSuccessResult(await readCiLogsHandler(ReadCiLogsInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await readCiLogsHandler(ReadCiLogsInputSchema.parse(normArgs)));
                     case "repo.logs":
-                        return createSuccessResult(await repoLogsHandler(RepoLogsInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await repoLogsHandler(RepoLogsInputSchema.parse(normArgs)));
+                    case "repo.create.branch":
                     case "repo.create_branch":
-                        return createSuccessResult(await createBranchHandler(CreateBranchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createBranchHandler(CreateBranchInputSchema.parse(normArgs)));
+                    case "repo.create.repair.branch":
                     case "repo.create_repair_branch":
-                        return createSuccessResult(await createRepairBranchHandler(CreateRepairBranchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createRepairBranchHandler(CreateRepairBranchInputSchema.parse(normArgs)));
+                    case "repo.run.tests":
                     case "repo.run_tests":
-                        return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await runTestsHandler(RunTestsInputSchema.parse(normArgs)));
+                    case "repo.run.lighthouse":
                     case "repo.run_lighthouse":
-                        return createSuccessResult(await runLighthouseHandler(RunLighthouseInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await runLighthouseHandler(RunLighthouseInputSchema.parse(normArgs)));
+                    case "repo.run.playwright":
                     case "repo.run_playwright":
-                        return createSuccessResult(await runPlaywrightHandler(RunPlaywrightInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await runPlaywrightHandler(RunPlaywrightInputSchema.parse(normArgs)));
+                    case "repo.commit.patch":
                     case "repo.commit_patch":
-                        return createSuccessResult(await commitPatchHandler(CommitPatchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await commitPatchHandler(CommitPatchInputSchema.parse(normArgs)));
+                    case "github.open.replacement.pr":
                     case "github.open_replacement_pr":
-                        return createSuccessResult(await openReplacementPrHandler(OpenReplacementPrInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await openReplacementPrHandler(OpenReplacementPrInputSchema.parse(normArgs)));
+                    case "github.comment.triage.summary":
                     case "github.comment_triage_summary":
-                        return createSuccessResult(await commentTriageSummaryHandler(CommentTriageSummaryInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await commentTriageSummaryHandler(CommentTriageSummaryInputSchema.parse(normArgs)));
+                    case "github.create.pull.request":
                     case "github.create_pull_request":
-                        return createSuccessResult(await createPullRequestHandler(CreatePullRequestInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createPullRequestHandler(CreatePullRequestInputSchema.parse(normArgs)));
+                    case "github.get.pr":
                     case "github.get_pr":
-                        return createSuccessResult(await getPrHandler(GetPrInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getPrHandler(GetPrInputSchema.parse(normArgs)));
+                    case "github.issue.view":
                     case "github.issue_view":
-                        return createSuccessResult(await issueViewHandler(IssueViewInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await issueViewHandler(IssueViewInputSchema.parse(normArgs)));
+                    case "github.issue.update":
                     case "github.issue_update":
-                        return createSuccessResult(await issueUpdateHandler(IssueUpdateInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await issueUpdateHandler(IssueUpdateInputSchema.parse(normArgs)));
+                    case "github.issue.comment":
                     case "github.issue_comment":
-                        return createSuccessResult(await issueCommentHandler(IssueCommentInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await issueCommentHandler(IssueCommentInputSchema.parse(normArgs)));
+                    case "github.create.issue":
                     case "github.create_issue":
-                        return createSuccessResult(await createIssueHandler(CreateIssueInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createIssueHandler(CreateIssueInputSchema.parse(normArgs)));
+                    case "jules.create.session":
                     case "jules.create_session":
-                        return createSuccessResult(await createJulesSessionHandler(CreateJulesSessionInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await createJulesSessionHandler(CreateJulesSessionInputSchema.parse(normArgs)));
+                    case "jules.get.session":
                     case "jules.get_session":
-                        return createSuccessResult(await getJulesSessionHandler(GetJulesSessionInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getJulesSessionHandler(GetJulesSessionInputSchema.parse(normArgs)));
+                    case "jules.send.message":
                     case "jules.send_message":
-                        return createSuccessResult(await sendJulesMessageHandler(SendJulesMessageInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await sendJulesMessageHandler(SendJulesMessageInputSchema.parse(normArgs)));
+                    case "jules.get.messages":
                     case "jules.get_messages":
-                        return createSuccessResult(await getJulesMessagesHandler(GetJulesMessagesInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getJulesMessagesHandler(GetJulesMessagesInputSchema.parse(normArgs)));
+                    case "jules.list.sessions":
                     case "jules.list_sessions":
-                        return createSuccessResult(await listJulesSessionsHandler(ListJulesSessionsInputSchema.parse(request.params.arguments || {})));
+                        return createSuccessResult(await listJulesSessionsHandler(ListJulesSessionsInputSchema.parse(normArgs)));
+                    case "jules.cancel.session":
                     case "jules.cancel_session":
-                        return createSuccessResult(await cancelJulesSessionHandler(CancelJulesSessionInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await cancelJulesSessionHandler(CancelJulesSessionInputSchema.parse(normArgs)));
+                    case "jules.get.pr":
                     case "jules.get_pr":
-                        return createSuccessResult(await getJulesPullRequestHandler(GetJulesPullRequestInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await getJulesPullRequestHandler(GetJulesPullRequestInputSchema.parse(normArgs)));
+                    case "jules.trigger.feedback":
                     case "jules.trigger_feedback":
-                        return createSuccessResult(await triggerJulesFeedbackHandler(TriggerJulesFeedbackInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await triggerJulesFeedbackHandler(TriggerJulesFeedbackInputSchema.parse(normArgs)));
+                    case "agent.search.ddgs":
                     case "agent.search_ddgs":
-                        return createSuccessResult(await ddgsSearchHandler(DdgsSearchInputSchema.parse(request.params.arguments)));
+                        return createSuccessResult(await ddgsSearchHandler(DdgsSearchInputSchema.parse(normArgs)));
                     default:
                         return createErrorResult(`Tool not found: ${request.params.name}`);
                 }