@wingman-ai/gateway 0.4.0 → 0.4.2

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/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 };

package/dist/agent/middleware/additional-messages.cjs

@@ -30,6 +30,7 @@ const external_node_path_namespaceObject = require("node:path");
 const external_langchain_namespaceObject = require("langchain");
 const external_utils_cjs_namespaceObject = require("../utils.cjs");
 const external_uiRegistry_cjs_namespaceObject = require("../uiRegistry.cjs");
+const INJECTION_SOURCE = "additional-message-middleware";
 const normalizeRelativePath = (value)=>value.replace(/\\/g, "/");
 const toSafeRelativePath = (workspaceRoot, targetPath)=>{
     if (!workspaceRoot) return null;
@@ -56,12 +57,108 @@ const buildWorkingDirectoryMessage = (context)=>{
     if (!context.workspaceRoot) return null;
     return "** Working Directory **\n- Treat `./` as the current working directory for file and tool operations in this session.\n- Use relative paths such as `./test.md`; do not prepend the working directory absolute path.";
 };
+const resolveConnectedNodeIds = async (context)=>{
+    if (context.nodeConnectedTargetsProvider) try {
+        const rawTargets = await context.nodeConnectedTargetsProvider();
+        if (!Array.isArray(rawTargets)) return [];
+        const seen = new Set();
+        const normalized = [];
+        for (const target of rawTargets){
+            if (!target || "object" != typeof target) continue;
+            const nodeId = target.nodeId?.trim();
+            if (!(!nodeId || seen.has(nodeId))) {
+                seen.add(nodeId);
+                normalized.push(nodeId);
+            }
+        }
+        return normalized;
+    } catch  {
+        return [];
+    }
+    if (!context.nodeConnectedIdsProvider) return [];
+    try {
+        const rawIds = await context.nodeConnectedIdsProvider();
+        if (!Array.isArray(rawIds)) return [];
+        const seen = new Set();
+        const normalized = [];
+        for (const value of rawIds){
+            if ("string" != typeof value) continue;
+            const trimmed = value.trim();
+            if (!(!trimmed || seen.has(trimmed))) {
+                seen.add(trimmed);
+                normalized.push(trimmed);
+            }
+        }
+        return normalized;
+    } catch  {
+        return [];
+    }
+};
+const resolveConnectedNodeTargets = async (context)=>{
+    if (context.nodeConnectedTargetsProvider) try {
+        const rawTargets = await context.nodeConnectedTargetsProvider();
+        if (!Array.isArray(rawTargets)) return [];
+        const seen = new Set();
+        const normalized = [];
+        for (const target of rawTargets){
+            if (!target || "object" != typeof target) continue;
+            const typedTarget = target;
+            const nodeId = typedTarget.nodeId?.trim();
+            if (!nodeId || seen.has(nodeId)) continue;
+            seen.add(nodeId);
+            const rawCapabilities = typedTarget.capabilities;
+            const capabilities = Array.isArray(rawCapabilities) ? rawCapabilities.filter((value)=>"string" == typeof value).map((value)=>value.trim()).filter(Boolean) : [];
+            normalized.push({
+                nodeId,
+                clientId: typedTarget.clientId?.trim() || void 0,
+                name: typedTarget.name?.trim() || void 0,
+                capabilities: capabilities.length > 0 ? capabilities : void 0
+            });
+        }
+        return normalized;
+    } catch  {
+        return [];
+    }
+    const nodeIds = await resolveConnectedNodeIds(context);
+    return nodeIds.map((nodeId)=>({
+            nodeId
+        }));
+};
+const buildNodeTargetsMessage = async (context)=>{
+    const connectedNodeTargets = await resolveConnectedNodeTargets(context);
+    const connectedNodeIds = connectedNodeTargets.map((target)=>target.nodeId);
+    const defaultClientId = context.defaultNodeTargetClientId?.trim();
+    if (0 === connectedNodeIds.length && !defaultClientId) return null;
+    const lines = [
+        "** Connected Node Targets **"
+    ];
+    if (connectedNodeIds.length > 0) lines.push(`- Connected node IDs: ${connectedNodeIds.join(", ")}`);
+    else lines.push("- Connected node IDs: (none currently connected)");
+    const withMetadata = connectedNodeTargets.filter((target)=>Boolean(target.clientId) || Boolean(target.name) || target.capabilities && target.capabilities.length > 0);
+    if (withMetadata.length > 0) {
+        lines.push("- Connected node metadata:");
+        for (const target of withMetadata.slice(0, 8)){
+            const details = [];
+            if (target.clientId) details.push(`clientId: ${target.clientId}`);
+            if (target.name) details.push(`name: ${target.name}`);
+            if (target.capabilities && target.capabilities.length > 0) {
+                const preview = target.capabilities.slice(0, 6).join(", ");
+                const remaining = target.capabilities.length - 6;
+                details.push(remaining > 0 ? `capabilities: ${preview} (+${remaining} more)` : `capabilities: ${preview}`);
+            }
+            if (details.length > 0) lines.push(`  - ${target.nodeId} (${details.join("; ")})`);
+        }
+        if (withMetadata.length > 8) lines.push(`  - ... ${withMetadata.length - 8} more connected node(s)`);
+    }
+    if (defaultClientId) lines.push(`- Default node target clientId for this request: ${defaultClientId}`);
+    lines.push("- For node_notify/node_run, set target.nodeId or target.clientId when the user specifies a device.");
+    return lines.join("\n");
+};
 const additionalMessageMiddleware = (context = {})=>({
-        name: "additional-message-middleware",
+        name: INJECTION_SOURCE,
         [external_langchain_namespaceObject.MIDDLEWARE_BRAND]: true,
         beforeAgent: async (input)=>{
-            const alreadyInjected = input.messages.some((message)=>message?.additional_kwargs?.source === "additional-message-middleware");
-            if (alreadyInjected) return input;
+            const messagesWithoutInjected = input.messages.filter((message)=>message?.additional_kwargs?.source !== INJECTION_SOURCE);
             const lines = [
                 (0, external_utils_cjs_namespaceObject.getConfidentialityNotice)(),
                 `** Current Date Time (UTC): ${new Date().toISOString()} **`
@@ -70,6 +167,8 @@ const additionalMessageMiddleware = (context = {})=>({
             if (outputLocation) lines.push(outputLocation);
             const workingDirectory = buildWorkingDirectoryMessage(context);
             if (workingDirectory) lines.push(workingDirectory);
+            const nodeTargets = await buildNodeTargetsMessage(context);
+            if (nodeTargets) lines.push(nodeTargets);
             lines.push("** Long-term memory **\n- Use /memories/ for durable notes across threads.\n- Store stable preferences, project context, decisions, and research notes.\n- Avoid transient logs; keep entries concise and organized.\n- Suggested paths: /memories/preferences.md, /memories/projects/<name>/context.md, /memories/projects/<name>/decisions.md");
             if (false === context.dynamicUiEnabled) lines.push("** Dynamic UI **\n- Dynamic UI rendering is disabled for this gateway.\n- Respond with plain text and avoid calling UI presentation tools.");
             else {
@@ -82,14 +181,19 @@ const additionalMessageMiddleware = (context = {})=>({
                     lines.push("** Dynamic UI Registry **\n" + summaryLines + "\n- Use ui_registry_get for schema details, then ui_present with textFallback.");
                 }
             }
-            input.messages.unshift(new external_langchain_namespaceObject.HumanMessage({
-                content: lines.join("\n\n"),
-                additional_kwargs: {
-                    ui_hidden: true,
-                    source: "additional-message-middleware"
-                }
-            }));
-            return input;
+            return {
+                ...input,
+                messages: [
+                    new external_langchain_namespaceObject.HumanMessage({
+                        content: lines.join("\n\n"),
+                        additional_kwargs: {
+                            ui_hidden: true,
+                            source: INJECTION_SOURCE
+                        }
+                    }),
+                    ...messagesWithoutInjected
+                ]
+            };
         }
     });
 exports.additionalMessageMiddleware = __webpack_exports__.additionalMessageMiddleware;

package/dist/agent/middleware/additional-messages.d.ts

@@ -1,4 +1,10 @@
 import { type AgentMiddleware } from "langchain";
+export type ConnectedNodeTarget = {
+    nodeId: string;
+    clientId?: string;
+    name?: string;
+    capabilities?: string[];
+};
 type AdditionalMessageContext = {
     workspaceRoot?: string | null;
     workdir?: string | null;
@@ -6,6 +12,9 @@ type AdditionalMessageContext = {
     outputVirtualPath?: string | null;
     dynamicUiEnabled?: boolean;
     skillsDirectory?: string;
+    nodeConnectedIdsProvider?: () => string[] | Promise<string[]>;
+    nodeConnectedTargetsProvider?: () => ConnectedNodeTarget[] | Promise<ConnectedNodeTarget[]>;
+    defaultNodeTargetClientId?: string;
 };
 export declare const additionalMessageMiddleware: (context?: AdditionalMessageContext) => AgentMiddleware;
 export {};