@arii/boomtick-mcp 0.4.2 → 0.6.0

package/src/tools/github.get_pr_reviews.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
+import { sanitizeError } from "../lib/error_utils.js";
+
+const GetPrReviewsInputSchema = z.object({
+  prNumber: z.number().describe("The number of the PR to view reviews for."),
+  repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
+});
+
+export async function getPrReviewsHandler(args: z.infer<typeof GetPrReviewsInputSchema>) {
+  const params = GetPrReviewsInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
+
+  const result = await runCommand("td", ["gh", "read-pr-reviews", "--pr-number", params.prNumber.toString(), "--repo", targetRepo]);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to read PR reviews: ${sanitizeError(result.stderr)}`);
+  }
+
+  const output = JSON.parse(result.stdout);
+  if (output.status === "error") {
+    throw new Error(`Failed to read PR reviews: ${output.message}`);
+  }
+
+  return { reviews: output.reviews, reviewCount: output.review_count };
+}

package/src/tools/github.issue_comment.ts

@@ -19,7 +19,7 @@ export async function issueCommentHandler(args: z.infer<typeof IssueCommentInput
   const params = IssueCommentInputSchema.parse(args);
   const targetRepo = resolveRepo(params.repo);
 
-  const result = await runCommand("td-cli", [
+  const result = await runCommand("td", [
     "gh", "issue-comment", params.issueNumber.toString(),
     "--body", params.body,
     "--repo", targetRepo

package/src/tools/github.issue_update.ts

@@ -19,7 +19,7 @@ export async function issueUpdateHandler(args: z.infer<typeof IssueUpdateInputSc
   if (params.state) cmdArgs.push("--state", params.state);
   cmdArgs.push("--repo", targetRepo);
 
-  const result = await runCommand("td-cli", cmdArgs);
+  const result = await runCommand("td", cmdArgs);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to update issue: ${sanitizeError(result.stderr)}`);

package/src/tools/github.issue_view.ts

@@ -23,7 +23,7 @@ export async function issueViewHandler(args: z.infer<typeof IssueViewInputSchema
   const params = IssueViewInputSchema.parse(args);
   const targetRepo = resolveRepo(params.repo);
 
-  const result = await runCommand("td-cli", ["gh", "issue-view", params.issueNumber.toString(), "--repo", targetRepo]);
+  const result = await runCommand("td", ["gh", "issue-view", params.issueNumber.toString(), "--repo", targetRepo]);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to view issue: ${sanitizeError(result.stderr)}`);

package/src/tools/github.search_open_prs.ts

@@ -29,7 +29,7 @@ export async function searchOpenPrsHandler(args: z.infer<typeof SearchOpenPrsInp
     tdArgs.push("--labels", params.labels.join(","));
   }
 
-  const result = await runCommand("td-cli", tdArgs);
+  const result = await runCommand("td", tdArgs);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to list PRs: ${result.stderr}`);

package/src/tools/jules/cancel-session.ts

@@ -7,7 +7,7 @@ export const CancelJulesSessionInputSchema = z.object({
 });
 
 export async function cancelJulesSessionHandler(input: z.infer<typeof CancelJulesSessionInputSchema>): Promise<JulesSession> {
-  const result = await runCommand("td-cli", ["agent", "cancel", input.sessionId]);
+  const result = await runCommand("td", ["agent", "cancel", input.sessionId]);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to cancel session: ${result.stderr}`);

package/src/tools/jules/create-session.test.ts

@@ -20,7 +20,7 @@ describe("createJulesSessionHandler", () => {
       stderr: "",
       exitCode: 0,
       durationMs: 10,
-      command: "td-cli agent dispatch"
+      command: "td agent dispatch"
     });
   });
 
@@ -35,7 +35,7 @@ describe("createJulesSessionHandler", () => {
     expect(result.status).toBe("IN_PROGRESS");
     expect(result.createdAt).toBeInstanceOf(Date);
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "dispatch", "main", "do work"
     ]);
   });
@@ -44,7 +44,7 @@ describe("createJulesSessionHandler", () => {
     const result = await createJulesSessionHandler({ task: "do work", branch: "feature-x" });
     expect(result.id).toBe("1234567890");
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "dispatch", "feature-x", "do work"
     ]);
   });
@@ -57,7 +57,7 @@ describe("createJulesSessionHandler", () => {
           stderr: "",
           exitCode: 0,
           durationMs: 10,
-          command: "td-cli gh view"
+          command: "td gh view"
         };
       }
       return {
@@ -70,18 +70,18 @@ describe("createJulesSessionHandler", () => {
         stderr: "",
         exitCode: 0,
         durationMs: 10,
-        command: "td-cli agent dispatch"
+        command: "td agent dispatch"
       };
     });
 
     const result = await createJulesSessionHandler({ task: "do work", pr: 42 });
     expect(result.id).toBe("1234567890");
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "gh", "view", "42"
     ]);
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "dispatch", "pr-branch", "do work"
     ]);
   });
@@ -92,11 +92,11 @@ describe("createJulesSessionHandler", () => {
       stderr: "Original error",
       exitCode: 1,
       durationMs: 10,
-      command: "td-cli gh view"
+      command: "td gh view"
     });
 
     await expect(createJulesSessionHandler({ task: "do work", pr: 999 }))
-      .rejects.toThrow("td-cli returned error: PR not found");
+      .rejects.toThrow("td returned error: PR not found");
   });
 
   it("should throw descriptive error if PR JSON is invalid", async () => {
@@ -105,10 +105,10 @@ describe("createJulesSessionHandler", () => {
       stderr: "",
       exitCode: 0,
       durationMs: 10,
-      command: "td-cli gh view"
+      command: "td gh view"
     });
 
     await expect(createJulesSessionHandler({ task: "do work", pr: 42 }))
-      .rejects.toThrow("td-cli returned non-JSON output with exit code 0: invalid json");
+      .rejects.toThrow("td returned non-JSON output with exit code 0: invalid json");
   });
 });

package/src/tools/jules/create-session.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { runTDCli } from "../../lib/td-cli.js";
-import { parseJulesSession } from "./shared.js";
+import { runTDCli, parseJulesSession } from "./shared.js";
 
 export const CreateJulesSessionInputSchema = z.object({
   task: z.string(),

package/src/tools/jules/get-messages.test.ts

@@ -17,7 +17,7 @@ describe("getJulesMessagesHandler", () => {
     vi.clearAllMocks();
   });
 
-  it("should return messages from td-cli", async () => {
+  it("should return messages from td", async () => {
     const mockMessages = [
       {
         role: "user",
@@ -36,7 +36,7 @@ describe("getJulesMessagesHandler", () => {
       stderr: "",
       exitCode: 0,
       durationMs: 0,
-      command: "td-cli agent messages"
+      command: "td agent messages"
     });
 
     const result = await getJulesMessagesHandler({ sessionId: "123" });
@@ -45,7 +45,7 @@ describe("getJulesMessagesHandler", () => {
     expect(result.messages[0].role).toBe("user");
     expect(result.messages[0].content).toBe("Hello Jules");
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "messages", "123"
     ]);
   });

package/src/tools/jules/get-messages.ts

@@ -6,7 +6,7 @@ export const GetJulesMessagesInputSchema = z.object({
 });
 
 export async function getJulesMessagesHandler(input: z.infer<typeof GetJulesMessagesInputSchema>) {
-  const result = await runCommand("td-cli", ["agent", "messages", input.sessionId]);
+  const result = await runCommand("td", ["agent", "messages", input.sessionId]);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to get messages: ${result.stderr}`);

package/src/tools/jules/get-pr.test.ts

@@ -17,7 +17,7 @@ describe("getJulesPullRequestHandler", () => {
     vi.clearAllMocks();
   });
 
-  it("should get PR from td-cli", async () => {
+  it("should get PR from td", async () => {
     vi.mocked(shell.runCommand).mockResolvedValue({
       stdout: JSON.stringify({
         status: "success",
@@ -29,14 +29,14 @@ describe("getJulesPullRequestHandler", () => {
       stderr: "",
       exitCode: 0,
       durationMs: 0,
-      command: "td-cli agent get-session"
+      command: "td agent get-session"
     });
 
     const result = await getJulesPullRequestHandler({ sessionId: "123" });
     expect(result.id).toBe("123");
     expect(result.pullRequestUrl).toBe("https://github.com/pr/1");
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "get-session", "123"
     ]);
   });

package/src/tools/jules/get-pr.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { runTDCli } from "../../lib/td-cli.js";
-import { parseJulesSession } from "./shared.js";
+import { runTDCli, parseJulesSession } from "./shared.js";
 
 export const GetJulesPullRequestInputSchema = z.object({
   sessionId: z.string(),

package/src/tools/jules/get-session.ts

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { runTDCli } from "../../lib/td-cli.js";
-import { parseJulesSession } from "./shared.js";
+import { runTDCli, parseJulesSession } from "./shared.js";
 
 export const GetJulesSessionInputSchema = z.object({
   sessionId: z.string(),

package/src/tools/jules/list-sessions.ts

@@ -8,7 +8,7 @@ export const ListJulesSessionsInputSchema = z.object({
 });
 
 export async function listJulesSessionsHandler(input: z.infer<typeof ListJulesSessionsInputSchema>): Promise<JulesSession[]> {
-  const result = await runCommand("td-cli", ["agent", "sync"]);
+  const result = await runCommand("td", ["agent", "sync"]);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to list sessions: ${result.stderr}`);

package/src/tools/jules/send-message.test.ts

@@ -17,20 +17,20 @@ describe("sendJulesMessageHandler", () => {
     vi.clearAllMocks();
   });
 
-  it("should send a message via td-cli", async () => {
+  it("should send a message via td", async () => {
     vi.mocked(shell.runCommand).mockResolvedValue({
       stdout: JSON.stringify({ status: "success", message: "Message sent successfully" }),
       stderr: "",
       exitCode: 0,
       durationMs: 0,
-      command: "td-cli agent send"
+      command: "td agent send"
     });
 
     const result = await sendJulesMessageHandler({ sessionId: "123", message: "hi" });
     expect(result.id).toBe("123");
     expect(result.status).toBe("success");
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "send", "123", "hi"
     ]);
   });
@@ -48,7 +48,7 @@ describe("sendJulesMessageHandler", () => {
       stderr: "",
       exitCode: 0,
       durationMs: 0,
-      command: "td-cli agent send"
+      command: "td agent send"
     });
 
     const result = await sendJulesMessageHandler({
@@ -59,7 +59,7 @@ describe("sendJulesMessageHandler", () => {
     expect(result.id).toEqual(["s1", "s2"]);
     expect(result.status).toBe("success");
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "send", "sessions/s1,sessions/s2", "hi batch"
     ]);
   });

package/src/tools/jules/send-message.ts

@@ -8,7 +8,7 @@ export const SendJulesMessageInputSchema = z.object({
 
 export async function sendJulesMessageHandler(input: z.infer<typeof SendJulesMessageInputSchema>) {
   const sessionIds = Array.isArray(input.sessionId) ? input.sessionId.join(",") : input.sessionId;
-  const result = await runCommand("td-cli", ["agent", "send", sessionIds, input.message]);
+  const result = await runCommand("td", ["agent", "send", sessionIds, input.message]);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to send message: ${result.stderr}`);

package/src/tools/jules/shared.ts

@@ -1,4 +1,39 @@
 import { JulesSession, JulesStatus } from "../types.js";
+import { runCommand } from "../../lib/shell.js";
+
+export interface TDCliResponse {
+  status?: string;
+  message?: string;
+  [key: string]: any;
+}
+
+function tryParseJson(text: string): TDCliResponse | null {
+  try {
+    return JSON.parse(text) as TDCliResponse;
+  } catch {
+    return null;
+  }
+}
+
+export async function runTDCli(args: string[]): Promise<TDCliResponse> {
+  const result = await runCommand("td", args);
+  const stdout = result.stdout.trim();
+  const output = stdout.startsWith("{") ? tryParseJson(stdout) : null;
+
+  if (output?.status === "error") {
+    throw new Error(`td returned error: ${output.message ?? "Unknown error"}`);
+  }
+
+  if (result.exitCode !== 0) {
+    throw new Error(`td command failed (${args.join(" ")}): ${result.stderr || stdout}`);
+  }
+
+  if (!output) {
+    throw new Error(`td returned non-JSON output with exit code 0: ${stdout}`);
+  }
+
+  return output;
+}
 
 export function parseJulesSession(data: any): JulesSession {
   const name = data.name || "";

package/src/tools/jules/trigger-feedback.test.ts

@@ -17,31 +17,31 @@ describe("triggerJulesFeedbackHandler", () => {
     vi.clearAllMocks();
   });
 
-  it("should return success output from td-cli", async () => {
+  it("should return success output from td", async () => {
     vi.mocked(shell.runCommand).mockResolvedValue({
       stdout: JSON.stringify({ status: "success", feedback: "All checks passed successfully. You may proceed." }),
       stderr: "",
       exitCode: 0,
       durationMs: 0,
-      command: "td-cli agent trigger-feedback"
+      command: "td agent trigger-feedback"
     });
 
     const result = await triggerJulesFeedbackHandler({ sessionId: "123" });
     expect(result.status).toBe("success");
     expect(result.feedback).toBe("All checks passed successfully. You may proceed.");
 
-    expect(shell.runCommand).toHaveBeenCalledWith("td-cli", [
+    expect(shell.runCommand).toHaveBeenCalledWith("td", [
       "agent", "trigger-feedback", "123"
     ]);
   });
 
-  it("should throw error if td-cli returns error", async () => {
+  it("should throw error if td returns error", async () => {
     vi.mocked(shell.runCommand).mockResolvedValue({
       stdout: JSON.stringify({ status: "error", message: "Session not found" }),
       stderr: "",
       exitCode: 0,
       durationMs: 0,
-      command: "td-cli agent trigger-feedback"
+      command: "td agent trigger-feedback"
     });
 
     await expect(triggerJulesFeedbackHandler({ sessionId: "123" }))

package/src/tools/jules/trigger-feedback.ts

@@ -6,7 +6,7 @@ export const TriggerJulesFeedbackInputSchema = z.object({
 });
 
 export async function triggerJulesFeedbackHandler(input: z.infer<typeof TriggerJulesFeedbackInputSchema>) {
-  const result = await runCommand("td-cli", ["agent", "trigger-feedback", input.sessionId]);
+  const result = await runCommand("td", ["agent", "trigger-feedback", input.sessionId]);
 
   if (result.exitCode !== 0) {
     throw new Error(`Failed to trigger feedback: ${result.stderr}`);

package/src/tools/repo.get_changed_files.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { runCommand } from "../lib/shell.js";
+import { getChangedFiles } from "../lib/git.js";
 
 export const GetChangedFilesInputSchema = z.object({
   base: z.string().optional().default("main"),
@@ -7,20 +7,6 @@ export const GetChangedFilesInputSchema = z.object({
 });
 
 export async function getChangedFilesHandler(args: z.infer<typeof GetChangedFilesInputSchema>) {
-  const result = await runCommand("git", [
-    "diff",
-    "--name-status",
-    `${args.base}...${args.head}`
-  ]);
-
-  if (result.exitCode !== 0) {
-    throw new Error(`Failed to get changed files: ${result.stderr}`);
-  }
-
-  const files = result.stdout.trim().split("\n").filter(line => line.length > 0).map(line => {
-    const [status, path] = line.split(/\s+/);
-    return { status, path };
-  });
-
+  const files = await getChangedFiles(args.base || "main", args.head || "HEAD");
   return { files };
 }

package/src/tools/repo.get_command_schema.ts

@@ -8,12 +8,12 @@ export const GetCommandSchemaInputSchema = z.object({
 export async function getCommandSchemaHandler(args: z.infer<typeof GetCommandSchemaInputSchema>) {
   // Sanitize input to prevent command injection (allow only alphanumeric, spaces, hyphens, and underscores)
   const sanitizedPath = args.commandPath.replace(/[^a-zA-Z0-9-_ ]/g, "");
-  const result = await runCommand("td-cli", ["schema", sanitizedPath]);
+  const result = await runCommand("td", ["schema", sanitizedPath]);
 
   if (result.exitCode !== 0) {
     // Log stderr for debugging but don't expose it to the user
     // Using comma-separated arguments to satisfy semgrep unsafe-formatstring
-    console.error("td-cli schema failed for", sanitizedPath, ":", result.stderr);
+    console.error("td schema failed for", sanitizedPath, ":", result.stderr);
     throw new Error(`Failed to get command schema for '${sanitizedPath}'`);
   }
 

package/src/tools/repo.get_workflow_runs.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { resolveRepo } from "../lib/git.js";
+import { sanitizeError } from "../lib/error_utils.js";
+
+const GetWorkflowRunsInputSchema = z.object({
+  branch: z.string().optional().describe("Filter workflow runs by branch name."),
+  event: z.string().optional().describe("Filter workflow runs by event (e.g. push, pull_request)."),
+  repo: z.string().optional().describe("The target repository override (e.g. org/repo)."),
+});
+
+export async function getWorkflowRunsHandler(args: z.infer<typeof GetWorkflowRunsInputSchema>) {
+  const params = GetWorkflowRunsInputSchema.parse(args);
+  const targetRepo = resolveRepo(params.repo);
+
+  const cliArgs = ["repo", "workflow-runs", "--repo", targetRepo];
+  if (params.branch) {
+    cliArgs.push("--branch", params.branch);
+  }
+  if (params.event) {
+    cliArgs.push("--event", params.event);
+  }
+
+  const result = await runCommand("td", cliArgs);
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to fetch workflow runs: ${sanitizeError(result.stderr)}`);
+  }
+
+  const output = JSON.parse(result.stdout);
+  if (output.status === "error") {
+    throw new Error(`Failed to fetch workflow runs: ${output.message}`);
+  }
+
+  return { workflowRuns: output.workflow_runs };
+}

package/src/tools/repo.logs.ts

@@ -1,9 +1,10 @@
 import { z } from "zod";
-import { runTDCli } from "../lib/td-cli.js";
+import { runTDCli } from "./jules/shared.js";
 
 export const RepoLogsInputSchema = z.object({
   prNumber: z.number(),
   grep: z.string().optional(),
+  repo: z.string().optional(),
 });
 
 export async function repoLogsHandler(args: z.infer<typeof RepoLogsInputSchema>) {
@@ -12,6 +13,9 @@ export async function repoLogsHandler(args: z.infer<typeof RepoLogsInputSchema>)
   if (args.grep) {
     params.push("--grep", args.grep);
   }
+  if (args.repo) {
+    params.push("--repo", args.repo);
+  }
 
   const output = await runTDCli(params);
 

package/src/tools/repo.read_agent_context.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { loadStandaloneAgentContext } from "../lib/td-cli.js";
+import { loadStandaloneAgentContext } from "./repo.read_agent_context.js";
 
 describe("Standalone Agent Context Loader", () => {
   it("should load agent context without submodule references", () => {

package/src/tools/repo.read_agent_context.ts

@@ -1,6 +1,40 @@
 import { z } from "zod";
 import { config } from "../config.js";
-import { loadStandaloneAgentContext } from "../lib/td-cli.js";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+
+export interface AgentContext {
+  packageName: string;
+  gitCommit: string;
+  config: Record<string, unknown>;
+}
+
+export const loadStandaloneAgentContext = (repoRoot: string = process.cwd()): AgentContext => {
+  const configPath = path.join(repoRoot, "project_config.json");
+  let projectConfig: Record<string, unknown> = {};
+
+  if (fs.existsSync(configPath)) {
+    try {
+      projectConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch (e) {
+      console.warn(`[MCP Warning] Failed to parse ${configPath}:`, e);
+    }
+  }
+
+  let gitCommit = "unknown";
+  try {
+    gitCommit = execSync("git rev-parse HEAD", { cwd: repoRoot, encoding: "utf-8" }).trim();
+  } catch {
+    // Fallback if git is unavailable
+  }
+
+  return {
+    packageName: (projectConfig.packageName as string) ?? "boomtick",
+    gitCommit,
+    config: projectConfig,
+  };
+};
 
 export const ReadAgentContextInputSchema = z.object({});
 

package/src/tools/repo.read_ci_logs.ts

@@ -1,9 +1,10 @@
 import { z } from "zod";
-import { runTDCli } from "../lib/td-cli.js";
+import { runTDCli } from "./jules/shared.js";
 
 export const ReadCiLogsInputSchema = z.object({
   prNumber: z.number(),
   all: z.boolean().optional(),
+  repo: z.string().optional(),
 });
 
 export async function readCiLogsHandler(args: z.infer<typeof ReadCiLogsInputSchema>) {
@@ -11,6 +12,9 @@ export async function readCiLogsHandler(args: z.infer<typeof ReadCiLogsInputSche
   if (args.all) {
     params.push("--all");
   }
+  if (args.repo) {
+    params.push("--repo", args.repo);
+  }
   const output = await runTDCli(params);
 
   return {

package/src/tools/repo.run_tests.ts

@@ -9,7 +9,7 @@ export const RunTestsInputSchema = z.object({
 
 export type RunTestsInput = z.input<typeof RunTestsInputSchema>;
 
-export function parseCommandArguments(fullCmd: string): [string, string[]] {
+function parseCommandArguments(fullCmd: string): [string, string[]] {
   const tokens: string[] = [];
   const regex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
   let match: RegExpExecArray | null;

package/.mcp/schemas/agent.search_ddgs.json

@@ -1,31 +0,0 @@
-{
-  "name": "agent.search_ddgs",
-  "description": "Search the web using DuckDuckGo (via ddgs python library).",
-  "parameters": {
-    "properties": {
-      "query": {
-        "description": "The search query.",
-        "title": "Query",
-        "type": "string"
-      },
-      "maxResults": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Maximum number of results to return.",
-        "title": "Maxresults"
-      }
-    },
-    "required": [
-      "query"
-    ],
-    "title": "SearchDdgsInput",
-    "type": "object"
-  }
-}

package/.mcp/schemas/agent_search_ddgs.json

@@ -1,31 +0,0 @@
-{
-  "name": "agent_search_ddgs",
-  "description": "Search the web using DuckDuckGo (via ddgs python library).",
-  "parameters": {
-    "properties": {
-      "query": {
-        "description": "The search query.",
-        "title": "Query",
-        "type": "string"
-      },
-      "maxResults": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Maximum number of results to return.",
-        "title": "Maxresults"
-      }
-    },
-    "required": [
-      "query"
-    ],
-    "title": "SearchDdgsInput",
-    "type": "object"
-  }
-}