haunter 0.1.0 → 0.2.1

package/README.md

@@ -56,6 +56,35 @@ haunter pages read PAGE_ID
 Lists show page IDs and titles. Reading a page prints its Markdown. Quote search
 phrases and task titles containing spaces.
 
+Rename a page without changing its content or location:
+
+```bash
+haunter pages rename PAGE_ID "Updated meeting notes"
+```
+
+Page titles can contain up to 300 characters.
+
+## Search your workspace and list canvases
+
+Search across pages, tasks, and canvases in your selected workspace:
+
+```bash
+haunter search "meeting notes"
+haunter search "meeting" --kind task
+haunter canvases list
+```
+
+Search queries must contain 2–200 characters. Search returns up to 20 matches
+per request; use `--limit 1..50` to change that or `--kind all|page|task|canvas`
+to filter the type. Each result shows its type, ID, title, and matching excerpt.
+
+When more results are available, the CLI prints a next cursor on stderr.
+Repeat the same query and `--kind` with `--cursor NEXT_CURSOR` to continue.
+With `--json`, the cursor is in the `nextCursor` field of the result.
+
+`canvases list` shows IDs and titles of standalone canvases. Canvases embedded
+inside pages are not included.
+
 ## Manage tasks
 
 ```bash
@@ -63,6 +92,9 @@ haunter tasks list
 haunter tasks list --due today
 haunter tasks add "Review proposal" --due 2026-12-12
 haunter tasks done TASK_ID
+haunter tasks reopen TASK_ID
+haunter tasks update TASK_ID --title "Review revised proposal" --due 2026-12-13
+haunter tasks update TASK_ID --clear-due
 ```
 
 Task lists default to your open tasks, with a limit of 50. Use
@@ -70,6 +102,56 @@ Task lists default to your open tasks, with a limit of 50. Use
 `--due today|overdue|upcoming`, and `--limit 1..200` to change the selection.
 Creating and completing tasks prints the task ID.
 
+`tasks reopen` marks a completed task as open. `tasks update` changes only the
+fields you supply. Use `--title` to rename a standalone task, `--due YYYY-MM-DD`
+to set its due date, or `--clear-due` to remove its date, time, and reminder.
+`--due` and `--clear-due` cannot be combined. To rename a task inside a page,
+edit its title in that page. Task titles can contain up to 1,000 characters.
+
+## Discover and call more tools
+
+Discover tools available to your signed-in connection, including new
+tools that don't have a dedicated CLI command:
+
+```bash
+haunter tools list
+haunter tools describe search_workspace
+haunter tools call search_workspace --input search.json --json
+```
+
+Create `search.json` with the arguments shown by `tools describe`:
+
+```json
+{"query":"meeting notes"}
+```
+
+The CLI checks the current tool list and argument schema each time you call a
+tool. New tools become available as the server adds them, within your approved
+permissions. Run `haunter login` again if you need different access. Tools
+reserved for embedded app interfaces are omitted. Tools requiring background
+MCP tasks are not supported.
+
+`--input` accepts a JSON file, or `-` for piped input. It must contain one JSON
+object, up to 1,000,000 bytes. Without `--input`, arguments start as `{}`:
+
+```bash
+printf '%s' '{"query":"meeting notes"}' | haunter tools call search_workspace --input - --json
+haunter tools call list_workspaces --json
+```
+
+For tools with a `workspaceId` argument, the CLI fills it from `--workspace`,
+`HAUNTER_WORKSPACE`, the saved selection, or the only approved workspace.
+A `workspaceId` supplied in JSON takes precedence over saved or environment
+defaults; a conflicting `--workspace` is an error. Tools without that argument
+don't use a default workspace and reject `--workspace`.
+
+`tools describe` and `tools call` print JSON, formatted for reading unless
+`--json` is set. Calls preserve the complete MCP result: `content`,
+`structuredContent`, and any metadata. Image data and resource links stay in
+the JSON; the CLI does not render or download them. A tool error also preserves
+the result on stdout, reports an error on stderr, and exits with code 1. Check
+the exit code before treating a result as successful.
+
 ## Use the CLI in scripts
 
 Add `--json` to get one JSON value on stdout:
@@ -90,8 +172,9 @@ may have been saved.
 
 ## Choose a workspace or server
 
-Pass `--workspace WORKSPACE_ID` (or `-w WORKSPACE_ID`) to a page, capture, or task
-command to override the saved workspace.
+Pass `--workspace WORKSPACE_ID` (or `-w WORKSPACE_ID`) to a search, canvas, page,
+capture, task, or workspace-scoped `tools call` command to override the saved
+workspace.
 
 | Setting | Flag | Environment variable | Default |
 | --- | --- | --- | --- |

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { createReadStream } from "node:fs";
+import { createReadStream as createReadStream2 } from "node:fs";
 import { stripVTControlCharacters } from "node:util";
 import { z as z2 } from "zod";
 // package.json
-var version = "0.1.0";
+var version = "0.2.1";
 
 // src/args.ts
 import { parseArgs } from "node:util";
@@ -19,7 +19,11 @@ var options = {
   page: { type: "string" },
   parent: { type: "string" },
   file: { type: "string" },
+  input: { type: "string" },
   due: { type: "string" },
+  "clear-due": { type: "boolean" },
+  kind: { type: "string" },
+  cursor: { type: "string" },
   filter: { type: "string" },
   scope: { type: "string" },
   limit: { type: "string" },
@@ -30,18 +34,29 @@ var commands = {
   login: { args: 0, flags: ["port", "no-browser"] },
   logout: { args: 0, flags: [] },
   status: { args: 0, flags: [] },
+  search: { args: 1, flags: ["workspace", "kind", "limit", "cursor"] },
+  "canvases list": { args: 0, flags: ["workspace"] },
+  "tools list": { args: 0, flags: [] },
+  "tools describe": { args: 1, flags: [] },
+  "tools call": { args: 1, flags: ["input", "workspace"] },
   "workspaces list": { args: 0, flags: [] },
   "workspaces use": { args: 1, flags: [] },
   "pages list": { args: 0, flags: ["workspace"] },
   "pages search": { args: 1, flags: ["workspace"] },
   "pages read": { args: 1, flags: ["workspace"] },
+  "pages rename": { args: 2, flags: ["workspace"] },
   capture: { args: 1, flags: ["workspace", "title", "page", "parent", "file"] },
   "tasks list": {
     args: 0,
     flags: ["workspace", "filter", "scope", "limit", "due"]
   },
   "tasks add": { args: 1, flags: ["workspace", "due"] },
-  "tasks done": { args: 1, flags: ["workspace"] }
+  "tasks done": { args: 1, flags: ["workspace"] },
+  "tasks reopen": { args: 1, flags: ["workspace"] },
+  "tasks update": {
+    args: 1,
+    flags: ["workspace", "title", "due", "clear-due"]
+  }
 };
 function parseArguments(args) {
   const parsed = parseArgs({
@@ -53,7 +68,13 @@ function parseArguments(args) {
   });
   const { values, positionals, tokens } = parsed;
   const group = positionals[0];
-  const grouped = ["pages", "tasks", "workspaces"].includes(group);
+  const grouped = [
+    "pages",
+    "tasks",
+    "workspaces",
+    "tools",
+    "canvases"
+  ].includes(group);
   const command = grouped ? `${group} ${positionals[1] ?? ""}`.trim() : group;
   const operands = positionals.slice(grouped ? 2 : 1);
   if (values.help || values.version || !group)
@@ -62,7 +83,7 @@ function parseArguments(args) {
   if (!spec)
     throw new Error(`Unknown command: ${command}. Run haunter --help.`);
   if (operands.length > spec.args || command !== "capture" && operands.length !== spec.args) {
-    throw new Error(`${command} expects ${spec.args ? "one argument (quote text containing spaces)" : "no arguments"}. Run haunter --help.`);
+    throw new Error(`${command} expects ${spec.args === 0 ? "no arguments" : `${spec.args === 1 ? "one argument" : `${spec.args} arguments`} (quote text containing spaces)`}. Run haunter --help.`);
   }
   const seen = new Set;
   for (const token of tokens) {
@@ -87,7 +108,25 @@ function parseArguments(args) {
   if (values.port)
     integer(values.port, "port", 1, 65535);
   if (values.limit)
-    integer(values.limit, "limit", 1, 200);
+    integer(values.limit, "limit", 1, command === "search" ? 50 : 200);
+  if (command === "search") {
+    if (operands[0].trim().length < 2 || operands[0].trim().length > 200)
+      throw new Error("Search queries must be between 2 and 200 characters.");
+    if (values.kind && !["all", "page", "task", "canvas"].includes(values.kind))
+      throw new Error("--kind must be all, page, task, or canvas.");
+    if (values.cursor && values.cursor.length > 4096)
+      throw new Error("--cursor must be a cursor returned by search (at most 4,096 characters).");
+  }
+  if (command === "pages rename" && operands[1].trim().length > 300)
+    throw new Error("Page titles must be 300 characters or fewer.");
+  if (command === "tasks update") {
+    if (!values.title && !values.due && !values["clear-due"])
+      throw new Error("Provide --title, --due, or --clear-due to update a task.");
+    if (values.due && values["clear-due"])
+      throw new Error("Use --due or --clear-due, not both.");
+    if (values.title && values.title.trim().length > 1000)
+      throw new Error("Task titles must be 1,000 characters or fewer.");
+  }
   if (values.filter && !["open", "completed", "all"].includes(values.filter))
     throw new Error("--filter must be open, completed, or all.");
   if (values.scope && !["mine", "everyone"].includes(values.scope))
@@ -97,7 +136,7 @@ function parseArguments(args) {
       if (!["today", "overdue", "upcoming"].includes(values.due))
         throw new Error("--due must be today, overdue, or upcoming for tasks list.");
     } else if (!/^\d{4}-\d{2}-\d{2}$/.test(values.due) || Number.isNaN(Date.parse(values.due)) || new Date(values.due).toISOString().slice(0, 10) !== values.due) {
-      throw new Error("--due must be a valid date in YYYY-MM-DD format for tasks add.");
+      throw new Error("--due must be a valid date in YYYY-MM-DD format for tasks add or update.");
     }
   }
   return { command, operands, values, help: false };
@@ -117,9 +156,15 @@ Usage: haunter <command> [options]
   status                        Show local sign-in and workspace settings
   workspaces list               List workspaces you approved
   workspaces use <id>            Save the default workspace for this server
+  search <query>                Search pages, tasks, and canvases
+    --kind <all|page|task|canvas> Filter the result type (default: all)
+    --limit <1-50>               Results per request (default: 20)
+    --cursor <cursor>            Continue the same search from its next cursor
+  canvases list                 List standalone canvases
   pages list                    List pages
   pages search <query>           Search pages (quote phrases)
   pages read <id>                Print a page as Markdown
+  pages rename <id> <title>      Rename a page (quote titles containing spaces)
   capture [text]                Create a page from text, a file, or stdin
     --title <title>              New page title (default: first nonempty line)
     --file <path>               Read Markdown from a file; use - for stdin
@@ -132,6 +177,15 @@ Usage: haunter <command> [options]
     --limit <1-200>              Maximum tasks (default: 50)
   tasks add <title>              Create a task; optional --due YYYY-MM-DD
   tasks done <id>                Complete a task
+  tasks reopen <id>              Reopen a completed task
+  tasks update <id>              Update a task's title or due date
+    --title <title>              New title for a standalone task
+    --due <YYYY-MM-DD>           Set the due date
+    --clear-due                  Clear the date, time, and reminder
+  tools list                    Discover tools available to your connection
+  tools describe <name>         Show a tool's description and JSON schemas
+  tools call <name>             Call a discovered tool with JSON arguments
+    --input <path|->            Read a JSON object from a file or stdin
 
 Options:
   -w, --workspace <id>           Override the saved workspace for a command
@@ -177,6 +231,7 @@ class AuthProvider {
   }
   get clientMetadata() {
     return {
+      application_type: "native",
       client_name: "Haunter CLI",
       client_uri: "https://www.haunter.app",
       redirect_uris: [this.redirectUrl],
@@ -366,6 +421,10 @@ ${url.href}`);
 // src/client.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import {
+  CallToolResultSchema,
+  ListToolsResultSchema
+} from "@modelcontextprotocol/sdk/types.js";
 async function connect(store, profile, signal) {
   if (!profile.tokens)
     throw new Error(LOGIN_REQUIRED);
@@ -387,6 +446,32 @@ async function connect(store, profile, signal) {
     throw error;
   }
   return {
+    async listTools() {
+      const tools = [];
+      const names = new Set;
+      const cursors = new Set;
+      let cursor;
+      for (let page = 0;page < 100; page++) {
+        const result = await client.request({
+          method: "tools/list",
+          params: cursor === undefined ? {} : { cursor }
+        }, ListToolsResultSchema, { timeout: 30000, signal });
+        for (const tool of result.tools) {
+          if (names.has(tool.name))
+            throw new Error(`Haunter listed duplicate tool ${tool.name}.`);
+          names.add(tool.name);
+          tools.push(tool);
+        }
+        cursor = result.nextCursor;
+        if (cursor === undefined)
+          return tools;
+        if (cursors.has(cursor))
+          throw new Error("Haunter repeated a tool-list cursor.");
+        cursors.add(cursor);
+      }
+      throw new Error("Haunter's tool list exceeded 100 pages.");
+    },
+    callTool: (name, args) => client.request({ method: "tools/call", params: { name, arguments: args } }, CallToolResultSchema, { timeout: 30000, signal }),
     async call(name, args) {
       const result = await client.callTool({ name, arguments: args }, undefined, { timeout: 30000, signal });
       const text = Array.isArray(result.content) ? result.content.filter((item) => item.type === "text").map((item) => item.text).join(`
@@ -405,6 +490,50 @@ async function connect(store, profile, signal) {
   };
 }
 
+// src/tools.ts
+import { createReadStream } from "node:fs";
+import { CfWorkerJsonSchemaValidator } from "@modelcontextprotocol/sdk/validation/cfworker";
+async function readToolInput(file, io) {
+  if (!file)
+    return {};
+  if (file === "-" && io.isTTY)
+    throw new Error("Pipe a JSON object into tools call --input -.");
+  const stream = file === "-" ? io.stdin : createReadStream(file);
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of stream) {
+    io.signal?.throwIfAborted();
+    const buffer = Buffer.from(chunk);
+    bytes += buffer.length;
+    if (bytes > 1e6)
+      throw new Error("Tool input exceeds 1,000,000 bytes.");
+    chunks.push(buffer);
+  }
+  let input;
+  try {
+    input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new Error("Tool input must be valid JSON.");
+  }
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    throw new Error("Tool input must be a JSON object.");
+  return input;
+}
+function isCliTool(tool) {
+  const ui = tool._meta?.ui;
+  if (!ui || typeof ui !== "object")
+    return true;
+  const visibility = ui.visibility;
+  return !Array.isArray(visibility) || visibility.includes("model");
+}
+function toolValidator(schema, name) {
+  try {
+    return new CfWorkerJsonSchemaValidator().getValidator(schema);
+  } catch {
+    throw new Error(`Cannot validate the schema for ${name}. Update the CLI and try again.`);
+  }
+}
+
 // src/config.ts
 import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, open, readFile, rename, unlink } from "node:fs/promises";
@@ -520,6 +649,24 @@ var taskRow = z2.object({
 }).passthrough();
 var tasksResult = z2.object({ tasks: z2.array(taskRow), hasMore: z2.boolean() });
 var savedPage = z2.object({ pageId: z2.string(), title: z2.string() });
+var canvasesResult = z2.object({
+  canvases: z2.array(z2.object({ canvasId: z2.string(), title: z2.string() }).passthrough())
+}).passthrough();
+var searchResult = z2.object({
+  items: z2.array(z2.object({
+    kind: z2.enum(["page", "task", "canvas"]),
+    id: z2.string(),
+    title: z2.string(),
+    snippet: z2.string()
+  }).passthrough()),
+  nextCursor: z2.string().nullable()
+}).passthrough();
+var taskActions = {
+  "tasks add": { tool: "create_task", label: "Created" },
+  "tasks done": { tool: "complete_task", label: "Completed" },
+  "tasks reopen": { tool: "reopen_task", label: "Reopened" },
+  "tasks update": { tool: "update_task", label: "Updated" }
+};
 async function runCli(args, io, dependencies = { connect, login }) {
   let secrets = [];
   let release;
@@ -539,6 +686,8 @@ async function runCli(args, io, dependencies = { connect, login }) {
       write({ help: HELP }, HELP.trimEnd());
       return 0;
     }
+    if (["pages rename", "tasks update", "tasks reopen"].includes(command))
+      uuid(operands[0]);
     const server = serverUrl(values.server ?? io.env.HAUNTER_SERVER ?? DEFAULT_SERVER);
     const store = new ProfileStore(configDirectory(io.env), server);
     release = await store.lock();
@@ -578,7 +727,46 @@ Workspace: ${status.workspaceId ?? "not selected"}`);
       return 0;
     }
     const markdown = command === "capture" ? await captureText(operands[0], values.file, io) : undefined;
+    const toolInput = command === "tools call" ? await readToolInput(values.input, io) : {};
     client = await dependencies.connect(store, profile, io.signal);
+    if (command.startsWith("tools ")) {
+      const tools = (await client.listTools()).filter(isCliTool);
+      if (command === "tools list") {
+        write({ tools }, tools.map((tool) => `${tool.name}	${oneLine(tool.description ?? tool.title ?? "")}`).join(`
+`) || "No tools available. Run haunter login to review access.");
+        return 0;
+      }
+      const tool = tools.find((item) => item.name === operands[0]);
+      if (!tool)
+        throw new Error(`Tool ${operands[0]} is not available to this connection. Run haunter tools list, or haunter login to review access.`);
+      if (command === "tools describe") {
+        write(tool, JSON.stringify(tool, null, 2));
+        return 0;
+      }
+      if (tool.execution?.taskSupport === "required")
+        throw new Error(`${tool.name} requires MCP task support, which this CLI does not support.`);
+      if (Object.hasOwn(tool.inputSchema.properties ?? {}, "workspaceId")) {
+        if (Object.hasOwn(toolInput, "workspaceId")) {
+          if (values.workspace && values.workspace !== toolInput.workspaceId)
+            throw new Error("--workspace conflicts with workspaceId in the JSON input.");
+        } else {
+          toolInput.workspaceId = await resolveWorkspace(client, values.workspace ?? io.env.HAUNTER_WORKSPACE ?? profile.workspaceId);
+        }
+      } else if (values.workspace) {
+        throw new Error(`${tool.name} does not accept --workspace.`);
+      }
+      const validation = toolValidator(tool.inputSchema, tool.name)(toolInput);
+      if (!validation.valid)
+        throw new Error(`Invalid arguments for ${tool.name}: ${validation.errorMessage}`);
+      const validateOutput = tool.outputSchema ? toolValidator(tool.outputSchema, tool.name) : undefined;
+      const result = await client.callTool(tool.name, toolInput);
+      write(result, JSON.stringify(result, null, 2));
+      if (result.isError)
+        throw new Error(`${tool.name} failed. See the tool result on stdout.`);
+      if (validateOutput && !validateOutput(result.structuredContent).valid)
+        throw new Error(`${tool.name} returned a result that does not match its output schema. The call was sent; check Haunter before repeating it.`);
+      return 0;
+    }
     if (command === "workspaces list" || command === "workspaces use") {
       const result = workspaceResult.parse(await client.call("list_workspaces", {}));
       if (command === "workspaces list")
@@ -594,15 +782,37 @@ Workspace: ${status.workspaceId ?? "not selected"}`);
       }
       return 0;
     }
-    let workspaceId = values.workspace ?? io.env.HAUNTER_WORKSPACE ?? profile.workspaceId;
-    if (!workspaceId) {
-      const result = workspaceResult.parse(await client.call("list_workspaces", {}));
-      if (result.workspaces.length !== 1)
-        throw new Error("Select a workspace with haunter workspaces use <id>, or pass --workspace <id>.");
-      workspaceId = result.workspaces[0].id;
-    }
+    const workspaceId = await resolveWorkspace(client, values.workspace ?? io.env.HAUNTER_WORKSPACE ?? profile.workspaceId);
     const workspace = { workspaceId };
-    if (command === "pages list" || command === "pages search") {
+    if (command === "search") {
+      const result = searchResult.parse(await client.call("search_workspace", {
+        ...workspace,
+        query: operands[0].trim(),
+        kind: values.kind ?? "all",
+        limit: values.limit ? Number(values.limit) : 20,
+        ...values.cursor ? { cursor: values.cursor } : {}
+      }));
+      write(result, result.items.map((item) => `${item.kind}	${item.id}	${oneLine(item.title || "Untitled")}${item.snippet ? `
+  ${oneLine(item.snippet)}` : ""}`).join(`
+`) || "No results found.");
+      if (result.nextCursor && !json)
+        io.stderr(`More results available. Repeat the same query and --kind with --cursor.
+Next cursor: ${oneLine(result.nextCursor)}
+`);
+    } else if (command === "canvases list") {
+      const result = canvasesResult.parse(await client.call("list_canvases", workspace));
+      write(result, result.canvases.map((canvas) => `${canvas.canvasId}	${oneLine(canvas.title || "Untitled")}`).join(`
+`) || "No standalone canvases found.");
+    } else if (command === "pages rename") {
+      const result = await client.call("update_page", {
+        ...workspace,
+        pageId: operands[0],
+        title: operands[1].trim()
+      });
+      const page = savedPage.parse(result);
+      write(result, `Renamed to ${oneLine(page.title)}
+${page.pageId}`);
+    } else if (command === "pages list" || command === "pages search") {
       const result = pagesResult.parse(await client.call(command === "pages list" ? "list_pages" : "search_pages", {
         ...workspace,
         ...command === "pages search" ? { query: operands[0] } : {}
@@ -643,15 +853,23 @@ ${page.pageId}`);
         io.stderr(`More tasks are available. Narrow the filters or increase --limit (maximum 200).
 `);
     } else {
-      const result = await client.call(command === "tasks add" ? "create_task" : "complete_task", {
+      const action = taskActions[command];
+      if (!action)
+        throw new Error(`Unsupported command: ${command}. Run haunter --help.`);
+      const result = await client.call(action.tool, {
         ...workspace,
         ...command === "tasks add" ? {
           title: operands[0],
           ...values.due ? { dueDate: values.due } : {}
-        } : { taskId: uuid(operands[0]) }
+        } : { taskId: uuid(operands[0]) },
+        ...command === "tasks update" ? {
+          ...values.title !== undefined ? { title: values.title.trim() } : {},
+          ...values.due !== undefined ? { dueDate: values.due } : {},
+          ...values["clear-due"] ? { dueDate: null } : {}
+        } : {}
       });
       const task = taskRow.parse(result);
-      write(result, `${command === "tasks add" ? "Created" : "Completed"} ${oneLine(task.title)}
+      write(result, `${action.label} ${oneLine(task.title)}
 ${task.taskId}`);
     }
     return 0;
@@ -673,6 +891,14 @@ ${task.taskId}`);
     });
   }
 }
+async function resolveWorkspace(client, selected) {
+  if (selected)
+    return selected;
+  const result = workspaceResult.parse(await client.call("list_workspaces", {}));
+  if (result.workspaces.length !== 1)
+    throw new Error("Select a workspace with haunter workspaces use <id>, or pass --workspace <id>.");
+  return result.workspaces[0].id;
+}
 function uuid(value) {
   if (!z2.uuid().safeParse(value).success)
     throw new Error("Expected a page or task ID in UUID format.");
@@ -686,7 +912,7 @@ async function captureText(text, file, io) {
   }
   if (!file && io.isTTY)
     throw new Error("Provide capture text, --file <path>, or pipe Markdown into haunter capture.");
-  const input = file && file !== "-" ? createReadStream(file) : io.stdin;
+  const input = file && file !== "-" ? createReadStream2(file) : io.stdin;
   const chunks = [];
   let bytes = 0;
   for await (const chunk of input) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "haunter",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"description": "Pages, notes, and tasks in Haunter from your terminal.",
 	"type": "module",
 	"bin": {
@@ -46,6 +46,7 @@
 		"prepack": "bun run check"
 	},
 	"dependencies": {
+		"@cfworker/json-schema": "4.1.1",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"zod": "4.6.7"
 	},