@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/agent/tools/background_terminal.d.ts

@@ -0,0 +1,41 @@
+import * as z from "zod";
+import type { TerminalSessionManager, TerminalSessionStatus } from "./terminal_session_manager.js";
+export interface BackgroundTerminalToolOptions {
+    workspace: string;
+    ownerId: string;
+    sessionManager: TerminalSessionManager;
+    envVariables?: Record<string, string>;
+    blockedCommands?: string[];
+    allowScriptExecution?: boolean;
+    commandTimeout?: number;
+}
+export declare const createBackgroundTerminalTool: (options: BackgroundTerminalToolOptions) => import("langchain").DynamicStructuredTool<z.ZodObject<{
+    command: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    chars: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    wait_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    max_output_chars: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, z.core.$strip>, {
+    command?: string;
+    session_id?: string;
+    chars?: string;
+    wait_ms?: number;
+    max_output_chars?: number;
+}, {
+    command?: string | undefined;
+    session_id?: string | undefined;
+    chars?: string | undefined;
+    wait_ms?: number | undefined;
+    max_output_chars?: number | undefined;
+}, {
+    session_id?: string;
+    status?: TerminalSessionStatus;
+    output?: string;
+    has_more?: boolean;
+    exit_code?: number | null;
+    signal?: NodeJS.Signals | null;
+    command?: string;
+    cwd?: string;
+    dropped_chars?: number;
+    error?: string;
+}, "background_terminal">;

package/dist/agent/tools/background_terminal.js

@@ -0,0 +1,94 @@
+import { tool } from "langchain";
+import { number, object, string } from "zod";
+import { DEFAULT_BLOCKED_COMMANDS } from "./command_execute.js";
+const normalizeCommandParts = (command)=>{
+    const commandParts = command.trim().split(/\s+/);
+    const commandName = (commandParts[0] || "").toLowerCase();
+    return commandName.split(/[\\/]/).pop() || "";
+};
+const isScriptCommand = (command)=>{
+    const normalized = command.trim().toLowerCase();
+    return normalized.endsWith(".sh") || normalized.endsWith(".bash") || normalized.endsWith(".zsh") || normalized.endsWith(".ps1") || normalized.endsWith(".cmd") || normalized.endsWith(".bat");
+};
+const createSafeEnv = (envVariables)=>{
+    const { NODE_OPTIONS, NODE_DEBUG, VSCODE_INSPECTOR_OPTIONS, ...cleanEnv } = process.env;
+    return {
+        ...cleanEnv,
+        FORCE_COLOR: "0",
+        NO_COLOR: "1",
+        GIT_PAGER: "cat",
+        ...envVariables ?? {}
+    };
+};
+const buildTerminalResponse = (payload)=>payload;
+const createBackgroundTerminalTool = (options)=>{
+    const { workspace, ownerId, sessionManager, envVariables, blockedCommands = DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, commandTimeout = 300000 } = options;
+    return tool(async ({ command, session_id, chars, wait_ms, max_output_chars })=>{
+        try {
+            if (command && session_id) return buildTerminalResponse({
+                error: "Provide either command or session_id, not both"
+            });
+            if (!command && !session_id) return buildTerminalResponse({
+                error: "Provide command to start a session or session_id to poll/write"
+            });
+            let resolvedSessionId = session_id;
+            if (command) {
+                const baseCommand = normalizeCommandParts(command);
+                if (blockedCommands.includes(baseCommand)) return buildTerminalResponse({
+                    error: `Command "${command}" rejected by blockedCommands policy`
+                });
+                if (!allowScriptExecution && isScriptCommand(command)) return buildTerminalResponse({
+                    error: `Command "${command}" rejected because script execution is disabled`
+                });
+                const session = sessionManager.startSession({
+                    ownerId,
+                    command,
+                    cwd: workspace,
+                    env: createSafeEnv(envVariables),
+                    runtimeLimitMs: commandTimeout
+                });
+                resolvedSessionId = session.sessionId;
+            }
+            if (!resolvedSessionId) return buildTerminalResponse({
+                error: "session_id is required"
+            });
+            if (chars && chars.length > 0) sessionManager.writeSession({
+                ownerId,
+                sessionId: resolvedSessionId,
+                chars
+            });
+            const pollResult = await sessionManager.pollSession({
+                ownerId,
+                sessionId: resolvedSessionId,
+                waitMs: wait_ms,
+                maxOutputChars: max_output_chars
+            });
+            return buildTerminalResponse({
+                session_id: pollResult.sessionId,
+                status: pollResult.status,
+                output: pollResult.output,
+                has_more: pollResult.hasMore,
+                exit_code: pollResult.exitCode,
+                signal: pollResult.signal,
+                command: pollResult.command,
+                cwd: pollResult.cwd,
+                dropped_chars: pollResult.droppedChars
+            });
+        } catch (error) {
+            return buildTerminalResponse({
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }, {
+        name: "background_terminal",
+        description: "Single background terminal interface for long-running sessions. Use this for commands that may not exit on their own (for example web servers, test watchers, or log tailing). Start a session with command, then poll or write using session_id. Use normal shell commands in-session (for example ps/jobs/kill) and control chars like \\u0003 to interrupt running programs.",
+        schema: object({
+            command: string().optional().describe("Command to start a new terminal session"),
+            session_id: string().optional().describe("Existing terminal session id for poll/write"),
+            chars: string().optional().default("").describe("Optional stdin text to write before polling"),
+            wait_ms: number().min(0).max(30000).optional().default(1000).describe("How long to wait for output before returning"),
+            max_output_chars: number().min(1).max(200000).optional().default(8000).describe("Maximum output characters to return")
+        })
+    });
+};
+export { createBackgroundTerminalTool };

package/dist/agent/tools/code_search.cjs

@@ -90,12 +90,12 @@ const createCodeSearchTool = (workspace)=>{
         }), {
         name: "code_search",
         description: "Search code patterns across the codebase using ripgrep (or grep as fallback). Fast and efficient for finding function definitions, variables, imports, or any text pattern. Returns file paths with line numbers and context.",
-        schema: external_zod_namespaceObject.z.object({
-            pattern: external_zod_namespaceObject.z.string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
-            path: external_zod_namespaceObject.z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to the active execution workspace."),
-            type: external_zod_namespaceObject.z.string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
-            context: external_zod_namespaceObject.z.number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
-            caseSensitive: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")
+        schema: external_zod_namespaceObject.object({
+            pattern: external_zod_namespaceObject.string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
+            path: external_zod_namespaceObject.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to the active execution workspace."),
+            type: external_zod_namespaceObject.string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
+            context: external_zod_namespaceObject.number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
+            caseSensitive: external_zod_namespaceObject.boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")
         })
     });
 };

package/dist/agent/tools/code_search.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * Creates a tool that searches code using ripgrep (or grep as fallback)
  * This provides fast, structured code search across the codebase

package/dist/agent/tools/code_search.js

@@ -1,5 +1,5 @@
 import { tool } from "langchain";
-import { z } from "zod";
+import { boolean as external_zod_boolean, number, object, string } from "zod";
 import { execSync, spawn } from "node:child_process";
 function isRipgrepAvailable() {
     try {
@@ -62,12 +62,12 @@ const createCodeSearchTool = (workspace)=>{
         }), {
         name: "code_search",
         description: "Search code patterns across the codebase using ripgrep (or grep as fallback). Fast and efficient for finding function definitions, variables, imports, or any text pattern. Returns file paths with line numbers and context.",
-        schema: z.object({
-            pattern: z.string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
-            path: z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to the active execution workspace."),
-            type: z.string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
-            context: z.number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
-            caseSensitive: z.boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")
+        schema: object({
+            pattern: string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
+            path: string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to the active execution workspace."),
+            type: string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
+            context: number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
+            caseSensitive: external_zod_boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")
         })
     });
 };

package/dist/agent/tools/command_execute.cjs

@@ -27,9 +27,9 @@ __webpack_require__.d(__webpack_exports__, {
     createCommandExecuteTool: ()=>createCommandExecuteTool,
     DEFAULT_BLOCKED_COMMANDS: ()=>DEFAULT_BLOCKED_COMMANDS
 });
+const external_node_child_process_namespaceObject = require("node:child_process");
 const external_langchain_namespaceObject = require("langchain");
 const external_zod_namespaceObject = require("zod");
-const external_node_child_process_namespaceObject = require("node:child_process");
 const DEFAULT_BLOCKED_COMMANDS = [
     "rm",
     "remove",
@@ -48,7 +48,22 @@ const DEFAULT_BLOCKED_COMMANDS = [
     "sudo",
     "su"
 ];
-const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, timeoutInMilliseconds = 300000)=>(0, external_langchain_namespaceObject.tool)(async ({ command })=>new Promise((resolve)=>{
+const DEFAULT_MAX_OUTPUT_CHARS = 200000;
+const TRUNCATION_HEAD_CHARS = 120000;
+const TRUNCATION_TAIL_CHARS = 80000;
+function appendCommandOutput(existing, incoming, maxChars) {
+    if (!incoming) return existing;
+    if (maxChars <= 0) return "";
+    const combined = existing + incoming;
+    if (combined.length <= maxChars) return combined;
+    const headBudget = Math.min(TRUNCATION_HEAD_CHARS, Math.floor(0.6 * maxChars));
+    const tailBudget = Math.min(TRUNCATION_TAIL_CHARS, Math.max(0, maxChars - headBudget));
+    const head = combined.slice(0, headBudget);
+    const tail = tailBudget > 0 ? combined.slice(-tailBudget) : "";
+    const omitted = Math.max(0, combined.length - head.length - tail.length);
+    return `${head}\n\n[output truncated: omitted ${omitted} chars]\n\n${tail}`;
+}
+const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, timeoutInMilliseconds = 300000, maxOutputChars = DEFAULT_MAX_OUTPUT_CHARS)=>(0, external_langchain_namespaceObject.tool)(async ({ command })=>new Promise((resolve)=>{
             try {
                 const commandParts = command.trim().split(/\s+/);
                 const commandName = (commandParts[0] || "").toLowerCase();
@@ -89,7 +104,7 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
                         hasExited = true;
                         try {
                             terminalProcess.kill();
-                        } catch (e) {}
+                        } catch  {}
                         const result = `Command: "${command}" timed out after ${timeoutInMilliseconds / 1000} seconds`;
                         resolve(result);
                     }
@@ -103,10 +118,10 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
                     }
                 };
                 terminalProcess.stdout?.on("data", (data)=>{
-                    output += data.toString();
+                    output = appendCommandOutput(output, data.toString(), maxOutputChars);
                 });
                 terminalProcess.stderr?.on("data", (data)=>{
-                    output += data.toString();
+                    output = appendCommandOutput(output, data.toString(), maxOutputChars);
                 });
                 terminalProcess.on("error", (err)=>{
                     resolveResponse(err.message, true);
@@ -121,8 +136,8 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
         }), {
         name: "command_execute",
         description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the active execution workspace context.",
-        schema: external_zod_namespaceObject.z.object({
-            command: external_zod_namespaceObject.z.string().describe("The command to execute in the terminal")
+        schema: external_zod_namespaceObject.object({
+            command: external_zod_namespaceObject.string().describe("The command to execute in the terminal")
         })
     });
 exports.DEFAULT_BLOCKED_COMMANDS = __webpack_exports__.DEFAULT_BLOCKED_COMMANDS;

package/dist/agent/tools/command_execute.d.ts

@@ -1,9 +1,10 @@
-import { z } from "zod";
+import * as z from "zod";
 export declare const DEFAULT_BLOCKED_COMMANDS: string[];
 /**
  * Creates a tool that executes terminal commands safely
  */
-export declare const createCommandExecuteTool: (workspace: string, envVariables?: Record<string, string>, blockedCommands?: string[], allowScriptExecution?: boolean, timeoutInMilliseconds?: number) => import("langchain").DynamicStructuredTool<z.ZodObject<{
+export declare const createCommandExecuteTool: (workspace: string, envVariables?: Record<string, string>, blockedCommands?: string[], allowScriptExecution?: boolean, timeoutInMilliseconds?: number, // Default timeout of 5 minutes
+maxOutputChars?: number) => import("langchain").DynamicStructuredTool<z.ZodObject<{
     command: z.ZodString;
 }, z.core.$strip>, {
     command: string;

package/dist/agent/tools/command_execute.js

@@ -1,6 +1,6 @@
-import { tool } from "langchain";
-import { z } from "zod";
 import { spawn } from "node:child_process";
+import { tool } from "langchain";
+import { object, string } from "zod";
 const DEFAULT_BLOCKED_COMMANDS = [
     "rm",
     "remove",
@@ -19,7 +19,22 @@ const DEFAULT_BLOCKED_COMMANDS = [
     "sudo",
     "su"
 ];
-const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, timeoutInMilliseconds = 300000)=>tool(async ({ command })=>new Promise((resolve)=>{
+const DEFAULT_MAX_OUTPUT_CHARS = 200000;
+const TRUNCATION_HEAD_CHARS = 120000;
+const TRUNCATION_TAIL_CHARS = 80000;
+function appendCommandOutput(existing, incoming, maxChars) {
+    if (!incoming) return existing;
+    if (maxChars <= 0) return "";
+    const combined = existing + incoming;
+    if (combined.length <= maxChars) return combined;
+    const headBudget = Math.min(TRUNCATION_HEAD_CHARS, Math.floor(0.6 * maxChars));
+    const tailBudget = Math.min(TRUNCATION_TAIL_CHARS, Math.max(0, maxChars - headBudget));
+    const head = combined.slice(0, headBudget);
+    const tail = tailBudget > 0 ? combined.slice(-tailBudget) : "";
+    const omitted = Math.max(0, combined.length - head.length - tail.length);
+    return `${head}\n\n[output truncated: omitted ${omitted} chars]\n\n${tail}`;
+}
+const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, timeoutInMilliseconds = 300000, maxOutputChars = DEFAULT_MAX_OUTPUT_CHARS)=>tool(async ({ command })=>new Promise((resolve)=>{
             try {
                 const commandParts = command.trim().split(/\s+/);
                 const commandName = (commandParts[0] || "").toLowerCase();
@@ -60,7 +75,7 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
                         hasExited = true;
                         try {
                             terminalProcess.kill();
-                        } catch (e) {}
+                        } catch  {}
                         const result = `Command: "${command}" timed out after ${timeoutInMilliseconds / 1000} seconds`;
                         resolve(result);
                     }
@@ -74,10 +89,10 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
                     }
                 };
                 terminalProcess.stdout?.on("data", (data)=>{
-                    output += data.toString();
+                    output = appendCommandOutput(output, data.toString(), maxOutputChars);
                 });
                 terminalProcess.stderr?.on("data", (data)=>{
-                    output += data.toString();
+                    output = appendCommandOutput(output, data.toString(), maxOutputChars);
                 });
                 terminalProcess.on("error", (err)=>{
                     resolveResponse(err.message, true);
@@ -92,8 +107,8 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
         }), {
         name: "command_execute",
         description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the active execution workspace context.",
-        schema: z.object({
-            command: z.string().describe("The command to execute in the terminal")
+        schema: object({
+            command: string().describe("The command to execute in the terminal")
         })
     });
 export { DEFAULT_BLOCKED_COMMANDS, createCommandExecuteTool };

package/dist/agent/tools/git_status.cjs

@@ -112,9 +112,9 @@ const createGitStatusTool = (workspace)=>(0, external_langchain_namespaceObject.
         }), {
         name: "git_status",
         description: "Get current git repository status including uncommitted changes, current branch, and optionally diff statistics. Read-only operation that helps understand the state before making changes.",
-        schema: external_zod_namespaceObject.z.object({
-            includeDiff: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Optional: Include summary of unstaged changes (diff --stat). Useful for understanding what has changed."),
-            includeStaged: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Optional: Include summary of staged changes (diff --cached --stat). Shows what will be committed.")
+        schema: external_zod_namespaceObject.object({
+            includeDiff: external_zod_namespaceObject.boolean().optional().default(false).describe("Optional: Include summary of unstaged changes (diff --stat). Useful for understanding what has changed."),
+            includeStaged: external_zod_namespaceObject.boolean().optional().default(false).describe("Optional: Include summary of staged changes (diff --cached --stat). Shows what will be committed.")
         })
     });
 exports.createGitStatusTool = __webpack_exports__.createGitStatusTool;

package/dist/agent/tools/git_status.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 /**
  * Creates a tool that gets git repository status (read-only)
  * Helps agents understand the current state without making modifications

package/dist/agent/tools/git_status.js

@@ -1,5 +1,5 @@
 import { tool } from "langchain";
-import { z } from "zod";
+import { boolean as external_zod_boolean, object } from "zod";
 import { spawn } from "node:child_process";
 const createGitStatusTool = (workspace)=>tool(async ({ includeDiff = false, includeStaged = false })=>new Promise((resolve)=>{
             try {
@@ -84,9 +84,9 @@ const createGitStatusTool = (workspace)=>tool(async ({ includeDiff = false, incl
         }), {
         name: "git_status",
         description: "Get current git repository status including uncommitted changes, current branch, and optionally diff statistics. Read-only operation that helps understand the state before making changes.",
-        schema: z.object({
-            includeDiff: z.boolean().optional().default(false).describe("Optional: Include summary of unstaged changes (diff --stat). Useful for understanding what has changed."),
-            includeStaged: z.boolean().optional().default(false).describe("Optional: Include summary of staged changes (diff --cached --stat). Shows what will be committed.")
+        schema: object({
+            includeDiff: external_zod_boolean().optional().default(false).describe("Optional: Include summary of unstaged changes (diff --stat). Useful for understanding what has changed."),
+            includeStaged: external_zod_boolean().optional().default(false).describe("Optional: Include summary of staged changes (diff --cached --stat). Shows what will be committed.")
         })
     });
 export { createGitStatusTool };

package/dist/agent/tools/internet_search.cjs

@@ -130,9 +130,9 @@ function createDuckDuckGoTool(maxResults) {
     }, {
         name: "internet_search",
         description: "Run a web search using DuckDuckGo",
-        schema: external_zod_namespaceObject.z.object({
-            query: external_zod_namespaceObject.z.string().describe("The search query"),
-            maxResults: external_zod_namespaceObject.z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        schema: external_zod_namespaceObject.object({
+            query: external_zod_namespaceObject.string().describe("The search query"),
+            maxResults: external_zod_namespaceObject.number().optional().default(maxResults).describe("Maximum number of results to return")
         })
     });
 }
@@ -154,9 +154,9 @@ function createPerplexityTool(maxResults) {
     }, {
         name: "internet_search",
         description: "Run a web search using Perplexity Sonar with built-in citations",
-        schema: external_zod_namespaceObject.z.object({
-            query: external_zod_namespaceObject.z.string().describe("The search query"),
-            maxResults: external_zod_namespaceObject.z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        schema: external_zod_namespaceObject.object({
+            query: external_zod_namespaceObject.string().describe("The search query"),
+            maxResults: external_zod_namespaceObject.number().optional().default(maxResults).describe("Maximum number of results to return")
         })
     });
 }

package/dist/agent/tools/internet_search.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod";
 import type { SearchConfig } from "../../cli/config/schema.js";
 /**
  * Create an internet search tool based on configuration

package/dist/agent/tools/internet_search.js

@@ -1,7 +1,7 @@
 import { tool } from "langchain";
 import { DuckDuckGoSearch } from "@langchain/community/tools/duckduckgo_search";
 import { ChatOpenAI } from "@langchain/openai";
-import { z } from "zod";
+import { number, object, string } from "zod";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -101,9 +101,9 @@ function createDuckDuckGoTool(maxResults) {
     }, {
         name: "internet_search",
         description: "Run a web search using DuckDuckGo",
-        schema: z.object({
-            query: z.string().describe("The search query"),
-            maxResults: z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        schema: object({
+            query: string().describe("The search query"),
+            maxResults: number().optional().default(maxResults).describe("Maximum number of results to return")
         })
     });
 }
@@ -125,9 +125,9 @@ function createPerplexityTool(maxResults) {
     }, {
         name: "internet_search",
         description: "Run a web search using Perplexity Sonar with built-in citations",
-        schema: z.object({
-            query: z.string().describe("The search query"),
-            maxResults: z.number().optional().default(maxResults).describe("Maximum number of results to return")
+        schema: object({
+            query: string().describe("The search query"),
+            maxResults: number().optional().default(maxResults).describe("Maximum number of results to return")
         })
     });
 }