@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/agent/config/toolRegistry.js

@@ -1,11 +1,13 @@
-import { createInternetSearchTool } from "../tools/internet_search.js";
-import { webCrawler } from "../tools/web_crawler.js";
-import { createCommandExecuteTool } from "../tools/command_execute.js";
-import { createThinkingTool } from "../tools/think.js";
+import { createLogger } from "../../logger.js";
+import { createBackgroundTerminalTool } from "../tools/background_terminal.js";
 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 { getSharedTerminalSessionManager } from "../tools/terminal_session_manager.js";
+import { createThinkingTool } from "../tools/think.js";
 import { createUiPresentTool, createUiRegistryGetTool, createUiRegistryListTool } from "../tools/ui_registry.js";
-import { createLogger } from "../../logger.js";
+import { webCrawler } from "../tools/web_crawler.js";
 import { MCPClientManager } from "./mcpClientManager.js";
 const logger = createLogger();
 const UI_TOOL_NAMES = [
@@ -14,7 +16,7 @@ const UI_TOOL_NAMES = [
     "ui_present"
 ];
 function createTool(name, options = {}) {
-    const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, searchConfig = {
+    const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, terminalOwnerId = "default", terminalSessionManager = getSharedTerminalSessionManager(), searchConfig = {
         provider: "duckduckgo",
         maxResults: 5
     }, skillsDirectory = "skills", dynamicUiEnabled = true } = options;
@@ -34,6 +36,16 @@ function createTool(name, options = {}) {
             return webCrawler;
         case "command_execute":
             return createCommandExecuteTool(runtimeWorkspace, process.env, blockedCommands, allowScriptExecution, timeout);
+        case "background_terminal":
+            return createBackgroundTerminalTool({
+                workspace: runtimeWorkspace,
+                ownerId: terminalOwnerId,
+                sessionManager: terminalSessionManager,
+                envVariables: process.env,
+                blockedCommands,
+                allowScriptExecution,
+                commandTimeout: timeout
+            });
         case "think":
             return createThinkingTool();
         case "code_search":
@@ -77,6 +89,7 @@ function getAvailableTools() {
         "internet_search",
         "web_crawler",
         "command_execute",
+        "background_terminal",
         "think",
         "code_search",
         "git_status",

package/dist/agent/middleware/hooks/types.cjs

@@ -30,22 +30,22 @@ __webpack_require__.d(__webpack_exports__, {
     HooksConfigSchema: ()=>HooksConfigSchema
 });
 const external_zod_namespaceObject = require("zod");
-const HookSchema = external_zod_namespaceObject.z.object({
-    type: external_zod_namespaceObject.z.literal("command").describe("Type of hook - currently only 'command' is supported"),
-    command: external_zod_namespaceObject.z.string().min(1).describe("Shell command to execute"),
-    timeout: external_zod_namespaceObject.z.number().positive().optional().default(60).describe("Timeout in seconds (default: 60)")
+const HookSchema = external_zod_namespaceObject.object({
+    type: external_zod_namespaceObject.literal("command").describe("Type of hook - currently only 'command' is supported"),
+    command: external_zod_namespaceObject.string().min(1).describe("Shell command to execute"),
+    timeout: external_zod_namespaceObject.number().positive().optional().default(60).describe("Timeout in seconds (default: 60)")
 });
-const HookMatcherSchema = external_zod_namespaceObject.z.object({
-    matcher: external_zod_namespaceObject.z.string().optional().describe("Pattern to match tool names (pipe-separated, wildcard, or regex)"),
-    hooks: external_zod_namespaceObject.z.array(HookSchema).min(1).describe("Array of hooks to execute when pattern matches")
+const HookMatcherSchema = external_zod_namespaceObject.object({
+    matcher: external_zod_namespaceObject.string().optional().describe("Pattern to match tool names (pipe-separated, wildcard, or regex)"),
+    hooks: external_zod_namespaceObject.array(HookSchema).min(1).describe("Array of hooks to execute when pattern matches")
 });
-const StopHookSchema = external_zod_namespaceObject.z.object({
-    hooks: external_zod_namespaceObject.z.array(HookSchema).min(1).describe("Array of hooks to execute when agent stops")
+const StopHookSchema = external_zod_namespaceObject.object({
+    hooks: external_zod_namespaceObject.array(HookSchema).min(1).describe("Array of hooks to execute when agent stops")
 });
-const HooksConfigSchema = external_zod_namespaceObject.z.object({
-    PreToolUse: external_zod_namespaceObject.z.array(HookMatcherSchema).optional().describe("Hooks that fire before tool execution (can block)"),
-    PostToolUse: external_zod_namespaceObject.z.array(HookMatcherSchema).optional().describe("Hooks that fire after tool completes (non-blocking)"),
-    Stop: external_zod_namespaceObject.z.array(StopHookSchema).optional().describe("Hooks that fire when agent completes (non-blocking)")
+const HooksConfigSchema = external_zod_namespaceObject.object({
+    PreToolUse: external_zod_namespaceObject.array(HookMatcherSchema).optional().describe("Hooks that fire before tool execution (can block)"),
+    PostToolUse: external_zod_namespaceObject.array(HookMatcherSchema).optional().describe("Hooks that fire after tool completes (non-blocking)"),
+    Stop: external_zod_namespaceObject.array(StopHookSchema).optional().describe("Hooks that fire when agent completes (non-blocking)")
 });
 exports.HookMatcherSchema = __webpack_exports__.HookMatcherSchema;
 exports.HookSchema = __webpack_exports__.HookSchema;

package/dist/agent/middleware/hooks/types.d.ts

@@ -3,7 +3,7 @@
  *
  * Validation schemas for hook configurations and runtime execution context
  */
-import { z } from "zod";
+import * as z from "zod";
 import type { ToolCallRequest, ToolMessage } from "langchain";
 /**
  * Zod schema for individual hook configuration

package/dist/agent/middleware/hooks/types.js

@@ -1,19 +1,19 @@
-import { z } from "zod";
-const HookSchema = z.object({
-    type: z.literal("command").describe("Type of hook - currently only 'command' is supported"),
-    command: z.string().min(1).describe("Shell command to execute"),
-    timeout: z.number().positive().optional().default(60).describe("Timeout in seconds (default: 60)")
+import { array, literal, number, object, string } from "zod";
+const HookSchema = object({
+    type: literal("command").describe("Type of hook - currently only 'command' is supported"),
+    command: string().min(1).describe("Shell command to execute"),
+    timeout: number().positive().optional().default(60).describe("Timeout in seconds (default: 60)")
 });
-const HookMatcherSchema = z.object({
-    matcher: z.string().optional().describe("Pattern to match tool names (pipe-separated, wildcard, or regex)"),
-    hooks: z.array(HookSchema).min(1).describe("Array of hooks to execute when pattern matches")
+const HookMatcherSchema = object({
+    matcher: string().optional().describe("Pattern to match tool names (pipe-separated, wildcard, or regex)"),
+    hooks: array(HookSchema).min(1).describe("Array of hooks to execute when pattern matches")
 });
-const StopHookSchema = z.object({
-    hooks: z.array(HookSchema).min(1).describe("Array of hooks to execute when agent stops")
+const StopHookSchema = object({
+    hooks: array(HookSchema).min(1).describe("Array of hooks to execute when agent stops")
 });
-const HooksConfigSchema = z.object({
-    PreToolUse: z.array(HookMatcherSchema).optional().describe("Hooks that fire before tool execution (can block)"),
-    PostToolUse: z.array(HookMatcherSchema).optional().describe("Hooks that fire after tool completes (non-blocking)"),
-    Stop: z.array(StopHookSchema).optional().describe("Hooks that fire when agent completes (non-blocking)")
+const HooksConfigSchema = object({
+    PreToolUse: array(HookMatcherSchema).optional().describe("Hooks that fire before tool execution (can block)"),
+    PostToolUse: array(HookMatcherSchema).optional().describe("Hooks that fire after tool completes (non-blocking)"),
+    Stop: array(StopHookSchema).optional().describe("Hooks that fire when agent completes (non-blocking)")
 });
 export { HookMatcherSchema, HookSchema, HooksConfigSchema, StopHookSchema };

package/dist/agent/tests/agentConfig.test.cjs

@@ -28,6 +28,7 @@ const agentConfig_cjs_namespaceObject = require("../config/agentConfig.cjs");
                     "think"
                 ],
                 model: "anthropic:claude-opus-4-5",
+                reasoningEffort: "high",
                 blockedCommands: [
                     "rm",
                     "mv"
@@ -43,6 +44,7 @@ const agentConfig_cjs_namespaceObject = require("../config/agentConfig.cjs");
                     "think"
                 ]);
                 (0, external_vitest_namespaceObject.expect)(result.data.model).toBe("anthropic:claude-opus-4-5");
+                (0, external_vitest_namespaceObject.expect)(result.data.reasoningEffort).toBe("high");
                 (0, external_vitest_namespaceObject.expect)(result.data.blockedCommands).toEqual([
                     "rm",
                     "mv"
@@ -61,13 +63,17 @@ const agentConfig_cjs_namespaceObject = require("../config/agentConfig.cjs");
                         name: "research-agent",
                         description: "Researches topics",
                         systemPrompt: "You are a researcher",
-                        model: "openai:gpt-4o"
+                        model: "openai:gpt-4o",
+                        reasoningEffort: "low"
                     }
                 ]
             };
             const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
             (0, external_vitest_namespaceObject.expect)(result.success).toBe(true);
-            if (result.success) (0, external_vitest_namespaceObject.expect)(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
+            if (result.success) {
+                (0, external_vitest_namespaceObject.expect)(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
+                (0, external_vitest_namespaceObject.expect)(result.data.subAgents?.[0].reasoningEffort).toBe("low");
+            }
         });
         (0, external_vitest_namespaceObject.it)("should fail when a sub-agent shares the same name as its parent", ()=>{
             const config = {
@@ -131,6 +137,17 @@ const agentConfig_cjs_namespaceObject = require("../config/agentConfig.cjs");
             const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
             (0, external_vitest_namespaceObject.expect)(result.success).toBe(false);
         });
+        (0, external_vitest_namespaceObject.it)("should fail validation for invalid reasoning effort", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "Test",
+                systemPrompt: "Test",
+                reasoningEffort: "extreme"
+            };
+            const result = (0, agentConfig_cjs_namespaceObject.validateAgentConfig)(config);
+            (0, external_vitest_namespaceObject.expect)(result.success).toBe(false);
+            if (!result.success) (0, external_vitest_namespaceObject.expect)(result.error).toContain("reasoningEffort");
+        });
         (0, external_vitest_namespaceObject.it)("should apply default values for optional fields", ()=>{
             const config = {
                 name: "test-agent",
@@ -173,7 +190,10 @@ const agentConfig_cjs_namespaceObject = require("../config/agentConfig.cjs");
                 "internet_search",
                 "web_crawler",
                 "command_execute",
+                "background_terminal",
                 "think",
+                "code_search",
+                "git_status",
                 "ui_registry_list",
                 "ui_registry_get",
                 "ui_present"

package/dist/agent/tests/agentConfig.test.js

@@ -26,6 +26,7 @@ describe("Agent Configuration Schema", ()=>{
                     "think"
                 ],
                 model: "anthropic:claude-opus-4-5",
+                reasoningEffort: "high",
                 blockedCommands: [
                     "rm",
                     "mv"
@@ -41,6 +42,7 @@ describe("Agent Configuration Schema", ()=>{
                     "think"
                 ]);
                 expect(result.data.model).toBe("anthropic:claude-opus-4-5");
+                expect(result.data.reasoningEffort).toBe("high");
                 expect(result.data.blockedCommands).toEqual([
                     "rm",
                     "mv"
@@ -59,13 +61,17 @@ describe("Agent Configuration Schema", ()=>{
                         name: "research-agent",
                         description: "Researches topics",
                         systemPrompt: "You are a researcher",
-                        model: "openai:gpt-4o"
+                        model: "openai:gpt-4o",
+                        reasoningEffort: "low"
                     }
                 ]
             };
             const result = validateAgentConfig(config);
             expect(result.success).toBe(true);
-            if (result.success) expect(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
+            if (result.success) {
+                expect(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
+                expect(result.data.subAgents?.[0].reasoningEffort).toBe("low");
+            }
         });
         it("should fail when a sub-agent shares the same name as its parent", ()=>{
             const config = {
@@ -129,6 +135,17 @@ describe("Agent Configuration Schema", ()=>{
             const result = validateAgentConfig(config);
             expect(result.success).toBe(false);
         });
+        it("should fail validation for invalid reasoning effort", ()=>{
+            const config = {
+                name: "test-agent",
+                description: "Test",
+                systemPrompt: "Test",
+                reasoningEffort: "extreme"
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(false);
+            if (!result.success) expect(result.error).toContain("reasoningEffort");
+        });
         it("should apply default values for optional fields", ()=>{
             const config = {
                 name: "test-agent",
@@ -171,7 +188,10 @@ describe("Agent Configuration Schema", ()=>{
                 "internet_search",
                 "web_crawler",
                 "command_execute",
+                "background_terminal",
                 "think",
+                "code_search",
+                "git_status",
                 "ui_registry_list",
                 "ui_registry_get",
                 "ui_present"

package/dist/agent/tests/agentLoader.test.cjs

@@ -1,8 +1,8 @@
 "use strict";
 var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
 const agentLoader_cjs_namespaceObject = require("../config/agentLoader.cjs");
 const TEST_CONFIG_DIR = ".wingman-test";
 (0, external_vitest_namespaceObject.describe)("AgentConfigLoader", ()=>{
@@ -244,6 +244,43 @@ Markdown agent`;
             (0, external_vitest_namespaceObject.expect)(agent).toBeDefined();
             (0, external_vitest_namespaceObject.expect)(agent?.systemPrompt).toContain("[[wingman:prompt-refinement]]");
             (0, external_vitest_namespaceObject.expect)(agent?.systemPrompt).toContain("/memories/agents/refiner-agent/instructions.md");
+            (0, external_vitest_namespaceObject.expect)(agent?.systemPrompt).toContain("overlay as secondary preference memory");
+        });
+        (0, external_vitest_namespaceObject.it)("should apply reasoningEffort when model supports it", async ()=>{
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "reasoning-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "reasoning-agent",
+                description: "Agent with reasoning effort",
+                systemPrompt: "You are a reasoner",
+                model: "openai:gpt-5.2-codex",
+                reasoningEffort: "high"
+            };
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agent = await loader.loadAgent("reasoning-agent");
+            const model = agent?.model;
+            (0, external_vitest_namespaceObject.expect)(model.reasoning?.effort).toBe("high");
+        });
+        (0, external_vitest_namespaceObject.it)("should normalize thinkingEffort alias to reasoningEffort", async ()=>{
+            const agentDir = (0, external_node_path_namespaceObject.join)(TEST_CONFIG_DIR, "agents", "legacy-thinking-agent");
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "legacy-thinking-agent",
+                description: "Agent with legacy thinking effort field",
+                systemPrompt: "You are a reasoner",
+                model: "openai:gpt-5.2-codex",
+                thinkingEffort: "medium"
+            };
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(TEST_CONFIG_DIR);
+            const agent = await loader.loadAgent("legacy-thinking-agent");
+            const model = agent?.model;
+            (0, external_vitest_namespaceObject.expect)(model.reasoning?.effort).toBe("medium");
         });
     });
 });

package/dist/agent/tests/agentLoader.test.js

@@ -1,6 +1,6 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { AgentLoader } from "../config/agentLoader.js";
 const TEST_CONFIG_DIR = ".wingman-test";
 describe("AgentConfigLoader", ()=>{
@@ -242,6 +242,43 @@ Markdown agent`;
             expect(agent).toBeDefined();
             expect(agent?.systemPrompt).toContain("[[wingman:prompt-refinement]]");
             expect(agent?.systemPrompt).toContain("/memories/agents/refiner-agent/instructions.md");
+            expect(agent?.systemPrompt).toContain("overlay as secondary preference memory");
+        });
+        it("should apply reasoningEffort when model supports it", async ()=>{
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "reasoning-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "reasoning-agent",
+                description: "Agent with reasoning effort",
+                systemPrompt: "You are a reasoner",
+                model: "openai:gpt-5.2-codex",
+                reasoningEffort: "high"
+            };
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agent = await loader.loadAgent("reasoning-agent");
+            const model = agent?.model;
+            expect(model.reasoning?.effort).toBe("high");
+        });
+        it("should normalize thinkingEffort alias to reasoningEffort", async ()=>{
+            const agentDir = join(TEST_CONFIG_DIR, "agents", "legacy-thinking-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            const config = {
+                name: "legacy-thinking-agent",
+                description: "Agent with legacy thinking effort field",
+                systemPrompt: "You are a reasoner",
+                model: "openai:gpt-5.2-codex",
+                thinkingEffort: "medium"
+            };
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(config));
+            const loader = new AgentLoader(TEST_CONFIG_DIR);
+            const agent = await loader.loadAgent("legacy-thinking-agent");
+            const model = agent?.model;
+            expect(model.reasoning?.effort).toBe("medium");
         });
     });
 });

package/dist/agent/tests/backgroundTerminal.test.cjs

@@ -0,0 +1,70 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const background_terminal_cjs_namespaceObject = require("../tools/background_terminal.cjs");
+const terminal_session_manager_cjs_namespaceObject = require("../tools/terminal_session_manager.cjs");
+(0, external_vitest_namespaceObject.describe)("background terminal tools", ()=>{
+    (0, external_vitest_namespaceObject.it)("describes long-running tasks in the tool description", ()=>{
+        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
+        try {
+            const tool = (0, background_terminal_cjs_namespaceObject.createBackgroundTerminalTool)({
+                workspace: process.cwd(),
+                ownerId: "description-owner",
+                sessionManager: manager
+            });
+            const description = String(tool.description);
+            (0, external_vitest_namespaceObject.expect)(description).toContain("may not exit on their own");
+            (0, external_vitest_namespaceObject.expect)(description).toContain("web servers");
+            (0, external_vitest_namespaceObject.expect)(description).toContain("test watchers");
+        } finally{
+            manager.dispose();
+        }
+    });
+    (0, external_vitest_namespaceObject.it)("rejects blocked commands", async ()=>{
+        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
+        try {
+            const tool = (0, background_terminal_cjs_namespaceObject.createBackgroundTerminalTool)({
+                workspace: process.cwd(),
+                ownerId: "test-owner",
+                sessionManager: manager,
+                blockedCommands: [
+                    "rm"
+                ]
+            });
+            const result = await tool.invoke({
+                command: "rm -rf ./tmp"
+            });
+            (0, external_vitest_namespaceObject.expect)(result.error).toContain("rejected");
+        } finally{
+            manager.dispose();
+        }
+    });
+    (0, external_vitest_namespaceObject.it)("supports start and write/poll flow", async ()=>{
+        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
+        try {
+            const tool = (0, background_terminal_cjs_namespaceObject.createBackgroundTerminalTool)({
+                workspace: process.cwd(),
+                ownerId: "owner-flow",
+                sessionManager: manager
+            });
+            const started = await tool.invoke({
+                command: "cat",
+                wait_ms: 10
+            });
+            (0, external_vitest_namespaceObject.expect)(typeof started.session_id).toBe("string");
+            const sessionId = String(started.session_id);
+            const writeResult = await tool.invoke({
+                session_id: sessionId,
+                chars: "hello\n",
+                wait_ms: 1000
+            });
+            (0, external_vitest_namespaceObject.expect)(String(writeResult.output || "")).toContain("hello");
+        } finally{
+            manager.dispose();
+        }
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tests/backgroundTerminal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent/tests/backgroundTerminal.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { createBackgroundTerminalTool } from "../tools/background_terminal.js";
+import { TerminalSessionManager } from "../tools/terminal_session_manager.js";
+describe("background terminal tools", ()=>{
+    it("describes long-running tasks in the tool description", ()=>{
+        const manager = new TerminalSessionManager();
+        try {
+            const tool = createBackgroundTerminalTool({
+                workspace: process.cwd(),
+                ownerId: "description-owner",
+                sessionManager: manager
+            });
+            const description = String(tool.description);
+            expect(description).toContain("may not exit on their own");
+            expect(description).toContain("web servers");
+            expect(description).toContain("test watchers");
+        } finally{
+            manager.dispose();
+        }
+    });
+    it("rejects blocked commands", async ()=>{
+        const manager = new TerminalSessionManager();
+        try {
+            const tool = createBackgroundTerminalTool({
+                workspace: process.cwd(),
+                ownerId: "test-owner",
+                sessionManager: manager,
+                blockedCommands: [
+                    "rm"
+                ]
+            });
+            const result = await tool.invoke({
+                command: "rm -rf ./tmp"
+            });
+            expect(result.error).toContain("rejected");
+        } finally{
+            manager.dispose();
+        }
+    });
+    it("supports start and write/poll flow", async ()=>{
+        const manager = new TerminalSessionManager();
+        try {
+            const tool = createBackgroundTerminalTool({
+                workspace: process.cwd(),
+                ownerId: "owner-flow",
+                sessionManager: manager
+            });
+            const started = await tool.invoke({
+                command: "cat",
+                wait_ms: 10
+            });
+            expect(typeof started.session_id).toBe("string");
+            const sessionId = String(started.session_id);
+            const writeResult = await tool.invoke({
+                session_id: sessionId,
+                chars: "hello\n",
+                wait_ms: 1000
+            });
+            expect(String(writeResult.output || "")).toContain("hello");
+        } finally{
+            manager.dispose();
+        }
+    });
+});

package/dist/agent/tests/commandExecuteTool.test.cjs

@@ -0,0 +1,29 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const command_execute_cjs_namespaceObject = require("../tools/command_execute.cjs");
+(0, external_vitest_namespaceObject.describe)("command_execute tool", ()=>{
+    (0, external_vitest_namespaceObject.it)("rejects blocked commands", async ()=>{
+        const tool = (0, command_execute_cjs_namespaceObject.createCommandExecuteTool)(process.cwd(), void 0, [
+            "rm"
+        ]);
+        const result = await tool.invoke({
+            command: "rm -rf ./tmp"
+        });
+        (0, external_vitest_namespaceObject.expect)(String(result)).toContain("rejected");
+    });
+    (0, external_vitest_namespaceObject.it)("truncates oversized output to avoid oversized tool payloads", async ()=>{
+        const tool = (0, command_execute_cjs_namespaceObject.createCommandExecuteTool)(process.cwd(), void 0, [], true, 30000, 120);
+        const result = await tool.invoke({
+            command: "node -e \"process.stdout.write('x'.repeat(400))\""
+        });
+        const output = String(result);
+        (0, external_vitest_namespaceObject.expect)(output).toContain("completed successfully");
+        (0, external_vitest_namespaceObject.expect)(output).toContain("output truncated");
+        (0, external_vitest_namespaceObject.expect)(output.length).toBeLessThan(800);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tests/commandExecuteTool.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent/tests/commandExecuteTool.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { createCommandExecuteTool } from "../tools/command_execute.js";
+describe("command_execute tool", ()=>{
+    it("rejects blocked commands", async ()=>{
+        const tool = createCommandExecuteTool(process.cwd(), void 0, [
+            "rm"
+        ]);
+        const result = await tool.invoke({
+            command: "rm -rf ./tmp"
+        });
+        expect(String(result)).toContain("rejected");
+    });
+    it("truncates oversized output to avoid oversized tool payloads", async ()=>{
+        const tool = createCommandExecuteTool(process.cwd(), void 0, [], true, 30000, 120);
+        const result = await tool.invoke({
+            command: "node -e \"process.stdout.write('x'.repeat(400))\""
+        });
+        const output = String(result);
+        expect(output).toContain("completed successfully");
+        expect(output).toContain("output truncated");
+        expect(output.length).toBeLessThan(800);
+    });
+});