@wingman-ai/gateway 0.3.2 → 0.4.1

package/README.md

@@ -123,128 +123,46 @@ wingman provider login ollama     # Optional
 wingman agent --local --agent <id> "prompt"
 ```
 
-## Gateway Configuration (All the Ways + Why)
+## Secure Skills + MCP Proxy (TL;DR)
 
-Gateway behavior can be configured in three layers (higher priority wins): runtime flags, environment variables, and `wingman.config.json`. Use the config file for persistent defaults, then override per run when needed.
+Main point: skill scanning and MCP proxy are separate toggles, both explicit, and `uv` checks only happen when the feature is enabled.
 
-### 1) `wingman.config.json` (persistent defaults)
+Key CLI commands:
 
-- `gateway.host` / `gateway.port` - bind address + port. Use `0.0.0.0` for LAN access, or change the port to avoid conflicts.
-- `gateway.stateDir` - where durable sessions and gateway state live. Point to fast local storage or a shared volume.
-- `gateway.fsRoots` - allowlist for Control UI working folders and output paths. Keep this tight for safety.
-- `gateway.auth.mode` / `gateway.auth.token` / `gateway.auth.password` - gateway auth strategy (token, password, or none) for remote access.
-- `gateway.auth.allowTailscale` - trust Tailscale identity headers so Tailnet users can access without tokens.
-- `gateway.controlUi.enabled` / `gateway.controlUi.port` - enable/disable Control UI and choose its port.
-- `gateway.controlUi.pairingRequired` - require pairing for Control UI clients (recommended).
-- `gateway.controlUi.allowInsecureAuth` - only for local dev when testing auth flows.
-- `gateway.adapters.discord.*` - Discord output adapter:
-  - `enabled`, `token`, `mentionOnly`, `allowBots`, `allowedGuilds`, `allowedChannels`
-  - `channelSessions` to pin channels to a session (or `agent:<id>:` to force routing)
-  - `sessionCommand` for ad-hoc session overrides
-  - `responseChunkSize` to fit Discord message limits
-  - Optional `gatewayUrl`, `gatewayToken`, `gatewayPassword` to point the adapter at a remote gateway
-
-### 2) Runtime flags (`wingman gateway start` / `run`)
-
-- `--host`, `--port` - override bind address + port for this run.
-- `--auth`, `--auth-mode`, `--token`, `--password` - enable auth without editing config.
-- `--discovery mdns|tailscale`, `--name` - advertise your gateway for LAN or Tailnet discovery.
-- `--max-nodes`, `--ping-interval`, `--ping-timeout` - tune scale and heartbeat behavior.
-- `--log-level` - dial verbosity for debugging or production.
-
-### 3) Environment overrides
-
-- `WINGMAN_GATEWAY_TOKEN` - supply a token at runtime so you don't store secrets in config.
-
-### Related gateway behavior (configured elsewhere)
-
-- `agents.bindings` - deterministic routing rules used by the gateway to select an agent per inbound channel/message.
-- `voice` - gateway TTS defaults (provider + settings), with optional per-agent overrides for voice-enabled UIs.
-
-### Example configs (common setups)
+```bash
+# gateway auth token
+wingman gateway token --generate
+export WINGMAN_GATEWAY_TOKEN="<token>"
 
-#### 1) Local dev (single user, no auth)
+# gateway runtime
+wingman gateway start
 
-```json
-{
-  "gateway": {
-    "host": "127.0.0.1",
-    "port": 18789,
-    "auth": { "mode": "none" },
-    "controlUi": { "enabled": true, "port": 18790 }
-  }
-}
+# skills
+wingman skill browse
+wingman skill install <skill-name>
+wingman skill list
+wingman skill remove <skill-name>
 ```
 
-#### 2) Shared LAN gateway (token auth + restricted outputs)
-
-```json
-{
-  "gateway": {
-    "host": "0.0.0.0",
-    "port": 18789,
-    "fsRoots": ["~/Projects", "~/.wingman/outputs"],
-    "auth": { "mode": "token" },
-    "controlUi": { "enabled": true, "port": 18790, "pairingRequired": true }
-  }
-}
-```
+- Skill scan runs on each `wingman skill install` only when `skills.security.scanOnInstall` is enabled.
+- MCP proxy runs at agent runtime only when `gateway.mcpProxy.enabled` is enabled.
+- If `uv` is missing for an enabled feature, Wingman fails with an error (no interactive prompt).
+- Full config examples: `../docs-website/docs/configuration/skills.mdx`, `../docs-website/docs/configuration/gateway.mdx`, `../docs-website/docs/configuration/wingman-config.mdx`.
 
-Tip: set `WINGMAN_GATEWAY_TOKEN` at runtime so you do not store tokens in config.
-
-#### 3) Headless gateway + Discord output adapter
-
-```json
-{
-  "gateway": {
-    "host": "0.0.0.0",
-    "port": 18789,
-    "auth": { "mode": "token" },
-    "controlUi": { "enabled": false },
-    "adapters": {
-      "discord": {
-        "enabled": true,
-        "token": "DISCORD_BOT_TOKEN",
-        "mentionOnly": true,
-        "allowedGuilds": ["123456789012345678"],
-        "allowedChannels": ["987654321098765432"],
-        "channelSessions": {
-          "987654321098765432": "agent:support:discord:channel:987654321098765432"
-        }
-      }
-    }
-  }
-}
-```
+## Configuration
 
-#### 4) Remote access over Tailscale + voice TTS
-
-```json
-{
-  "gateway": {
-    "host": "0.0.0.0",
-    "port": 18789,
-    "auth": { "mode": "token", "allowTailscale": true },
-    "controlUi": { "enabled": true, "port": 18790, "pairingRequired": true }
-  },
-  "voice": {
-    "provider": "elevenlabs",
-    "defaultPolicy": "off",
-    "elevenlabs": {
-      "voiceId": "VOICE_ID",
-      "modelId": "eleven_multilingual_v2",
-      "stability": 0.4,
-      "similarityBoost": 0.7
-    }
-  }
-}
-```
+Where to configure:
 
-Start discovery at runtime:
+- Runtime flags: `wingman gateway start --help`
+- Environment secret: `WINGMAN_GATEWAY_TOKEN`
+- Persistent config: `.wingman/wingman.config.json`
+- JSON schema: `https://getwingmanai.com/schemas/wingman.config.schema.json`
 
-```bash
-wingman gateway start --discovery tailscale --name "Work Gateway"
-```
+Docs (full examples):
+
+- Gateway: `../docs-website/docs/configuration/gateway.mdx`
+- Skills: `../docs-website/docs/configuration/skills.mdx`
+- Full config: `../docs-website/docs/configuration/wingman-config.mdx`
 
 ## Core Concepts
 

package/dist/agent/config/agentConfig.cjs

@@ -42,6 +42,8 @@ const AvailableToolNames = external_zod_namespaceObject["enum"]([
     "browser_control",
     "command_execute",
     "background_terminal",
+    "node_notify",
+    "node_run",
     "think",
     "code_search",
     "git_status",

package/dist/agent/config/agentConfig.d.ts

@@ -9,6 +9,8 @@ export declare const AvailableToolNames: z.ZodEnum<{
     browser_control: "browser_control";
     command_execute: "command_execute";
     background_terminal: "background_terminal";
+    node_notify: "node_notify";
+    node_run: "node_run";
     think: "think";
     code_search: "code_search";
     git_status: "git_status";
@@ -44,6 +46,8 @@ export declare const AgentConfigSchema: z.ZodObject<{
         browser_control: "browser_control";
         command_execute: "command_execute";
         background_terminal: "background_terminal";
+        node_notify: "node_notify";
+        node_run: "node_run";
         think: "think";
         code_search: "code_search";
         git_status: "git_status";
@@ -148,6 +152,8 @@ export declare const AgentConfigSchema: z.ZodObject<{
             browser_control: "browser_control";
             command_execute: "command_execute";
             background_terminal: "background_terminal";
+            node_notify: "node_notify";
+            node_run: "node_run";
             think: "think";
             code_search: "code_search";
             git_status: "git_status";

package/dist/agent/config/agentConfig.js

@@ -9,6 +9,8 @@ const AvailableToolNames = external_zod_enum([
     "browser_control",
     "command_execute",
     "background_terminal",
+    "node_notify",
+    "node_run",
     "think",
     "code_search",
     "git_status",

package/dist/agent/config/agentLoader.cjs

@@ -45,6 +45,10 @@ function _define_property(obj, key, value) {
 }
 const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
 const PROMPT_REFINEMENT_MARKER = "[[wingman:prompt-refinement]]";
+const ALWAYS_ON_TOOL_NAMES = [
+    ...external_toolRegistry_cjs_namespaceObject.UI_TOOL_NAMES,
+    ...external_toolRegistry_cjs_namespaceObject.NODE_TOOL_NAMES
+];
 const normalizePromptRefinementPath = (agentName, rawPath)=>{
     const fallback = `/memories/agents/${agentName}/instructions.md`;
     if (!rawPath) return fallback;
@@ -244,16 +248,23 @@ class AgentLoader {
                 ...this.runtimeToolOptions
             };
         };
+        const addAlwaysOnTools = async (existingTools, source)=>{
+            const alwaysOnTools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)([
+                ...ALWAYS_ON_TOOL_NAMES
+            ], buildToolOptions(source));
+            if (0 === alwaysOnTools.length) return existingTools || [];
+            if (existingTools && existingTools.length > 0) {
+                const existing = new Set(existingTools.map((tool)=>tool.name));
+                const uniqueAlwaysOnTools = alwaysOnTools.filter((tool)=>!existing.has(tool.name));
+                return [
+                    ...existingTools,
+                    ...uniqueAlwaysOnTools
+                ];
+            }
+            return alwaysOnTools;
+        };
         if (config.tools && config.tools.length > 0) agent.tools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)(config.tools, buildToolOptions(config));
-        const uiTools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)(external_toolRegistry_cjs_namespaceObject.UI_TOOL_NAMES, buildToolOptions(config));
-        if (uiTools.length > 0) if (agent.tools && agent.tools.length > 0) {
-            const existing = new Set(agent.tools.map((tool)=>tool.name));
-            const uniqueUiTools = uiTools.filter((tool)=>!existing.has(tool.name));
-            agent.tools = [
-                ...agent.tools,
-                ...uniqueUiTools
-            ];
-        } else agent.tools = uiTools;
+        agent.tools = await addAlwaysOnTools(agent.tools, config);
         if (config.mcp) agent.mcpConfig = config.mcp;
         if (config.mcpUseGlobal) agent.mcpUseGlobal = true;
         if (config.model) try {
@@ -280,15 +291,7 @@ class AgentLoader {
                     sub.systemPrompt = applyPromptRefinement(sub.systemPrompt, subagent.name, subagent.promptRefinement);
                 }
                 if (subagent.tools && subagent.tools.length > 0) sub.tools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)(subagent.tools, buildToolOptions(subagent));
-                const subUiTools = await (0, external_toolRegistry_cjs_namespaceObject.createTools)(external_toolRegistry_cjs_namespaceObject.UI_TOOL_NAMES, buildToolOptions(subagent));
-                if (subUiTools.length > 0) if (sub.tools && sub.tools.length > 0) {
-                    const existing = new Set(sub.tools.map((tool)=>tool.name));
-                    const uniqueUiTools = subUiTools.filter((tool)=>!existing.has(tool.name));
-                    sub.tools = [
-                        ...sub.tools,
-                        ...uniqueUiTools
-                    ];
-                } else sub.tools = subUiTools;
+                sub.tools = await addAlwaysOnTools(sub.tools, subagent);
                 if (subagent.model) try {
                     sub.model = external_modelFactory_cjs_namespaceObject.ModelFactory.createModel(subagent.model, {
                         reasoningEffort: subagent.reasoningEffort,

package/dist/agent/config/agentLoader.js

@@ -4,7 +4,7 @@ import { load } from "js-yaml";
 import { createLogger } from "../../logger.js";
 import { WingmanDirectory, validateAgentConfig } from "./agentConfig.js";
 import { ModelFactory } from "./modelFactory.js";
-import { UI_TOOL_NAMES, createTools } from "./toolRegistry.js";
+import { NODE_TOOL_NAMES, UI_TOOL_NAMES, createTools } from "./toolRegistry.js";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -17,6 +17,10 @@ function _define_property(obj, key, value) {
 }
 const logger = createLogger();
 const PROMPT_REFINEMENT_MARKER = "[[wingman:prompt-refinement]]";
+const ALWAYS_ON_TOOL_NAMES = [
+    ...UI_TOOL_NAMES,
+    ...NODE_TOOL_NAMES
+];
 const normalizePromptRefinementPath = (agentName, rawPath)=>{
     const fallback = `/memories/agents/${agentName}/instructions.md`;
     if (!rawPath) return fallback;
@@ -216,16 +220,23 @@ class AgentLoader {
                 ...this.runtimeToolOptions
             };
         };
+        const addAlwaysOnTools = async (existingTools, source)=>{
+            const alwaysOnTools = await createTools([
+                ...ALWAYS_ON_TOOL_NAMES
+            ], buildToolOptions(source));
+            if (0 === alwaysOnTools.length) return existingTools || [];
+            if (existingTools && existingTools.length > 0) {
+                const existing = new Set(existingTools.map((tool)=>tool.name));
+                const uniqueAlwaysOnTools = alwaysOnTools.filter((tool)=>!existing.has(tool.name));
+                return [
+                    ...existingTools,
+                    ...uniqueAlwaysOnTools
+                ];
+            }
+            return alwaysOnTools;
+        };
         if (config.tools && config.tools.length > 0) agent.tools = await createTools(config.tools, buildToolOptions(config));
-        const uiTools = await createTools(UI_TOOL_NAMES, buildToolOptions(config));
-        if (uiTools.length > 0) if (agent.tools && agent.tools.length > 0) {
-            const existing = new Set(agent.tools.map((tool)=>tool.name));
-            const uniqueUiTools = uiTools.filter((tool)=>!existing.has(tool.name));
-            agent.tools = [
-                ...agent.tools,
-                ...uniqueUiTools
-            ];
-        } else agent.tools = uiTools;
+        agent.tools = await addAlwaysOnTools(agent.tools, config);
         if (config.mcp) agent.mcpConfig = config.mcp;
         if (config.mcpUseGlobal) agent.mcpUseGlobal = true;
         if (config.model) try {
@@ -252,15 +263,7 @@ class AgentLoader {
                     sub.systemPrompt = applyPromptRefinement(sub.systemPrompt, subagent.name, subagent.promptRefinement);
                 }
                 if (subagent.tools && subagent.tools.length > 0) sub.tools = await createTools(subagent.tools, buildToolOptions(subagent));
-                const subUiTools = await createTools(UI_TOOL_NAMES, buildToolOptions(subagent));
-                if (subUiTools.length > 0) if (sub.tools && sub.tools.length > 0) {
-                    const existing = new Set(sub.tools.map((tool)=>tool.name));
-                    const uniqueUiTools = subUiTools.filter((tool)=>!existing.has(tool.name));
-                    sub.tools = [
-                        ...sub.tools,
-                        ...uniqueUiTools
-                    ];
-                } else sub.tools = subUiTools;
+                sub.tools = await addAlwaysOnTools(sub.tools, subagent);
                 if (subagent.model) try {
                     sub.model = ModelFactory.createModel(subagent.model, {
                         reasoningEffort: subagent.reasoningEffort,

package/dist/agent/config/mcpClientManager.cjs

@@ -52,15 +52,7 @@ class MCPClientManager {
             for (const [key, value] of Object.entries(stdioServer.env || {}))resolvedEnv[key] = resolveEnvValue(value);
             const runtimeEnv = this.applyRuntimeEnv(resolvedEnv);
             const defaultToolTimeout = getDefaultToolTimeout(stdioServer);
-            mcpServers[server.name] = {
-                transport: "stdio",
-                command: stdioServer.command,
-                args: stdioServer.args || [],
-                env: runtimeEnv,
-                ...void 0 !== defaultToolTimeout ? {
-                    defaultToolTimeout
-                } : {}
-            };
+            mcpServers[server.name] = this.buildStdioServerConfig(stdioServer, runtimeEnv, defaultToolTimeout);
         } else if ("sse" === server.transport) {
             const sseServer = server;
             const defaultToolTimeout = getDefaultToolTimeout(sseServer);
@@ -83,6 +75,51 @@ class MCPClientManager {
             }
         };
     }
+    buildStdioServerConfig(server, env, defaultToolTimeout) {
+        const baseConfig = {
+            transport: "stdio",
+            command: server.command,
+            args: server.args || [],
+            env,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+        if (!this.proxyConfig?.enabled) return baseConfig;
+        const proxyCommand = this.proxyConfig.command?.trim() || "uvx";
+        const proxyBaseArgs = this.proxyConfig.baseArgs && this.proxyConfig.baseArgs.length > 0 ? this.proxyConfig.baseArgs : [
+            "invariant-gateway@latest",
+            "mcp"
+        ];
+        const proxyEnv = {
+            ...env
+        };
+        if (this.proxyConfig.apiKey) proxyEnv.INVARIANT_API_KEY = this.proxyConfig.apiKey;
+        if (this.proxyConfig.apiUrl) {
+            proxyEnv.INVARIANT_API_URL = this.proxyConfig.apiUrl;
+            proxyEnv.GUARDRAILS_API_URL = this.proxyConfig.apiUrl;
+        }
+        const proxyArgs = [
+            ...proxyBaseArgs,
+            "--project-name",
+            this.proxyConfig.projectName || "wingman-gateway",
+            ...this.proxyConfig.pushExplorer ? [
+                "--push-explorer"
+            ] : [],
+            "--exec",
+            baseConfig.command,
+            ...baseConfig.args || []
+        ];
+        return {
+            transport: "stdio",
+            command: proxyCommand,
+            args: proxyArgs,
+            env: proxyEnv,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+    }
     applyRuntimeEnv(env) {
         if (!this.executionWorkspace) return env;
         const next = {
@@ -176,9 +213,11 @@ class MCPClientManager {
         _define_property(this, "logger", void 0);
         _define_property(this, "serverConfigs", void 0);
         _define_property(this, "executionWorkspace", void 0);
+        _define_property(this, "proxyConfig", void 0);
         this.logger = logger;
         this.serverConfigs = this.mergeConfigs(configs);
         this.executionWorkspace = options?.executionWorkspace?.trim() || null;
+        this.proxyConfig = options?.proxyConfig;
     }
 }
 function resolveEnvValue(value) {

package/dist/agent/config/mcpClientManager.d.ts

@@ -1,6 +1,15 @@
 import type { StructuredTool } from "@langchain/core/tools";
 import type { Logger } from "@/logger.js";
 import type { MCPServersConfig } from "@/types/mcp.js";
+export type MCPProxyConfig = {
+    enabled?: boolean;
+    command?: string;
+    baseArgs?: string[];
+    projectName?: string;
+    pushExplorer?: boolean;
+    apiKey?: string;
+    apiUrl?: string;
+};
 /**
  * Manages MCP server connections and tool retrieval
  * Handles server lifecycle: initialization, tool loading, and cleanup
@@ -10,8 +19,10 @@ export declare class MCPClientManager {
     private logger;
     private serverConfigs;
     private executionWorkspace;
+    private proxyConfig;
     constructor(configs: MCPServersConfig[], logger: Logger, options?: {
         executionWorkspace?: string | null;
+        proxyConfig?: MCPProxyConfig;
     });
     /**
      * Merge multiple MCP configurations (global + agent-specific)
@@ -22,6 +33,7 @@ export declare class MCPClientManager {
      * Convert Wingman MCP config to MultiServerMCPClient format
      */
     private buildClientConfig;
+    private buildStdioServerConfig;
     private applyRuntimeEnv;
     /**
      * Initialize MCP client and connect to servers

package/dist/agent/config/mcpClientManager.js

@@ -24,15 +24,7 @@ class MCPClientManager {
             for (const [key, value] of Object.entries(stdioServer.env || {}))resolvedEnv[key] = resolveEnvValue(value);
             const runtimeEnv = this.applyRuntimeEnv(resolvedEnv);
             const defaultToolTimeout = getDefaultToolTimeout(stdioServer);
-            mcpServers[server.name] = {
-                transport: "stdio",
-                command: stdioServer.command,
-                args: stdioServer.args || [],
-                env: runtimeEnv,
-                ...void 0 !== defaultToolTimeout ? {
-                    defaultToolTimeout
-                } : {}
-            };
+            mcpServers[server.name] = this.buildStdioServerConfig(stdioServer, runtimeEnv, defaultToolTimeout);
         } else if ("sse" === server.transport) {
             const sseServer = server;
             const defaultToolTimeout = getDefaultToolTimeout(sseServer);
@@ -55,6 +47,51 @@ class MCPClientManager {
             }
         };
     }
+    buildStdioServerConfig(server, env, defaultToolTimeout) {
+        const baseConfig = {
+            transport: "stdio",
+            command: server.command,
+            args: server.args || [],
+            env,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+        if (!this.proxyConfig?.enabled) return baseConfig;
+        const proxyCommand = this.proxyConfig.command?.trim() || "uvx";
+        const proxyBaseArgs = this.proxyConfig.baseArgs && this.proxyConfig.baseArgs.length > 0 ? this.proxyConfig.baseArgs : [
+            "invariant-gateway@latest",
+            "mcp"
+        ];
+        const proxyEnv = {
+            ...env
+        };
+        if (this.proxyConfig.apiKey) proxyEnv.INVARIANT_API_KEY = this.proxyConfig.apiKey;
+        if (this.proxyConfig.apiUrl) {
+            proxyEnv.INVARIANT_API_URL = this.proxyConfig.apiUrl;
+            proxyEnv.GUARDRAILS_API_URL = this.proxyConfig.apiUrl;
+        }
+        const proxyArgs = [
+            ...proxyBaseArgs,
+            "--project-name",
+            this.proxyConfig.projectName || "wingman-gateway",
+            ...this.proxyConfig.pushExplorer ? [
+                "--push-explorer"
+            ] : [],
+            "--exec",
+            baseConfig.command,
+            ...baseConfig.args || []
+        ];
+        return {
+            transport: "stdio",
+            command: proxyCommand,
+            args: proxyArgs,
+            env: proxyEnv,
+            ...void 0 !== defaultToolTimeout ? {
+                defaultToolTimeout
+            } : {}
+        };
+    }
     applyRuntimeEnv(env) {
         if (!this.executionWorkspace) return env;
         const next = {
@@ -148,9 +185,11 @@ class MCPClientManager {
         _define_property(this, "logger", void 0);
         _define_property(this, "serverConfigs", void 0);
         _define_property(this, "executionWorkspace", void 0);
+        _define_property(this, "proxyConfig", void 0);
         this.logger = logger;
         this.serverConfigs = this.mergeConfigs(configs);
         this.executionWorkspace = options?.executionWorkspace?.trim() || null;
+        this.proxyConfig = options?.proxyConfig;
     }
 }
 function resolveEnvValue(value) {

package/dist/agent/config/toolRegistry.cjs

@@ -27,6 +27,7 @@ __webpack_require__.d(__webpack_exports__, {
     createTools: ()=>createTools,
     UI_TOOL_NAMES: ()=>UI_TOOL_NAMES,
     getAvailableTools: ()=>getAvailableTools,
+    NODE_TOOL_NAMES: ()=>NODE_TOOL_NAMES,
     createTool: ()=>createTool
 });
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
@@ -36,6 +37,7 @@ const code_search_cjs_namespaceObject = require("../tools/code_search.cjs");
 const command_execute_cjs_namespaceObject = require("../tools/command_execute.cjs");
 const git_status_cjs_namespaceObject = require("../tools/git_status.cjs");
 const internet_search_cjs_namespaceObject = require("../tools/internet_search.cjs");
+const node_invoke_cjs_namespaceObject = require("../tools/node_invoke.cjs");
 const terminal_session_manager_cjs_namespaceObject = require("../tools/terminal_session_manager.cjs");
 const think_cjs_namespaceObject = require("../tools/think.cjs");
 const ui_registry_cjs_namespaceObject = require("../tools/ui_registry.cjs");
@@ -47,6 +49,10 @@ const UI_TOOL_NAMES = [
     "ui_registry_get",
     "ui_present"
 ];
+const NODE_TOOL_NAMES = [
+    "node_notify",
+    "node_run"
+];
 function createTool(name, options = {}) {
     const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, terminalOwnerId = "default", terminalSessionManager = (0, terminal_session_manager_cjs_namespaceObject.getSharedTerminalSessionManager)(), searchConfig = {
         provider: "duckduckgo",
@@ -93,6 +99,16 @@ function createTool(name, options = {}) {
                 allowScriptExecution,
                 commandTimeout: timeout
             });
+        case "node_notify":
+            return (0, node_invoke_cjs_namespaceObject.createNodeNotifyTool)({
+                nodeInvoker: options.nodeInvoker,
+                defaultTargetClientId: options.nodeDefaultTargetClientId
+            });
+        case "node_run":
+            return (0, node_invoke_cjs_namespaceObject.createNodeRunTool)({
+                nodeInvoker: options.nodeInvoker,
+                defaultTargetClientId: options.nodeDefaultTargetClientId
+            });
         case "think":
             return (0, think_cjs_namespaceObject.createThinkingTool)();
         case "code_search":
@@ -140,17 +156,20 @@ function getAvailableTools() {
         "browser_control",
         "command_execute",
         "background_terminal",
+        ...NODE_TOOL_NAMES,
         "think",
         "code_search",
         "git_status",
         ...UI_TOOL_NAMES
     ];
 }
+exports.NODE_TOOL_NAMES = __webpack_exports__.NODE_TOOL_NAMES;
 exports.UI_TOOL_NAMES = __webpack_exports__.UI_TOOL_NAMES;
 exports.createTool = __webpack_exports__.createTool;
 exports.createTools = __webpack_exports__.createTools;
 exports.getAvailableTools = __webpack_exports__.getAvailableTools;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "NODE_TOOL_NAMES",
     "UI_TOOL_NAMES",
     "createTool",
     "createTools",

package/dist/agent/config/toolRegistry.d.ts

@@ -1,6 +1,7 @@
 import type { StructuredTool } from "@langchain/core/tools";
 import type { MCPServersConfig } from "@/types/mcp.js";
 import type { SearchConfig } from "../../cli/config/schema.js";
+import { type NodeInvokeRequest, type NodeInvokeResult } from "../tools/node_invoke.js";
 import { type TerminalSessionManager } from "../tools/terminal_session_manager.js";
 import type { AvailableToolName } from "./agentConfig.js";
 export interface ToolOptions {
@@ -30,8 +31,11 @@ export interface ToolOptions {
     mcpConfigs?: MCPServersConfig[];
     skillsDirectory?: string;
     dynamicUiEnabled?: boolean;
+    nodeInvoker?: (request: NodeInvokeRequest) => Promise<NodeInvokeResult>;
+    nodeDefaultTargetClientId?: string;
 }
 export declare const UI_TOOL_NAMES: AvailableToolName[];
+export declare const NODE_TOOL_NAMES: AvailableToolName[];
 /**
  * Create a tool by name with optional configuration
  */

package/dist/agent/config/toolRegistry.js

@@ -5,6 +5,7 @@ import { createCodeSearchTool } from "../tools/code_search.js";
 import { createCommandExecuteTool } from "../tools/command_execute.js";
 import { createGitStatusTool } from "../tools/git_status.js";
 import { createInternetSearchTool } from "../tools/internet_search.js";
+import { createNodeNotifyTool, createNodeRunTool } from "../tools/node_invoke.js";
 import { getSharedTerminalSessionManager } from "../tools/terminal_session_manager.js";
 import { createThinkingTool } from "../tools/think.js";
 import { createUiPresentTool, createUiRegistryGetTool, createUiRegistryListTool } from "../tools/ui_registry.js";
@@ -16,6 +17,10 @@ const UI_TOOL_NAMES = [
     "ui_registry_get",
     "ui_present"
 ];
+const NODE_TOOL_NAMES = [
+    "node_notify",
+    "node_run"
+];
 function createTool(name, options = {}) {
     const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, terminalOwnerId = "default", terminalSessionManager = getSharedTerminalSessionManager(), searchConfig = {
         provider: "duckduckgo",
@@ -62,6 +67,16 @@ function createTool(name, options = {}) {
                 allowScriptExecution,
                 commandTimeout: timeout
             });
+        case "node_notify":
+            return createNodeNotifyTool({
+                nodeInvoker: options.nodeInvoker,
+                defaultTargetClientId: options.nodeDefaultTargetClientId
+            });
+        case "node_run":
+            return createNodeRunTool({
+                nodeInvoker: options.nodeInvoker,
+                defaultTargetClientId: options.nodeDefaultTargetClientId
+            });
         case "think":
             return createThinkingTool();
         case "code_search":
@@ -109,10 +124,11 @@ function getAvailableTools() {
         "browser_control",
         "command_execute",
         "background_terminal",
+        ...NODE_TOOL_NAMES,
         "think",
         "code_search",
         "git_status",
         ...UI_TOOL_NAMES
     ];
 }
-export { UI_TOOL_NAMES, createTool, createTools, getAvailableTools };
+export { NODE_TOOL_NAMES, UI_TOOL_NAMES, createTool, createTools, getAvailableTools };