@wingman-ai/gateway 0.2.2 → 0.2.4

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

@@ -1,9 +1,9 @@
 "use strict";
 var __webpack_exports__ = {};
-const external_vitest_namespaceObject = require("vitest");
-const modelFactory_cjs_namespaceObject = require("../config/modelFactory.cjs");
 const anthropic_namespaceObject = require("@langchain/anthropic");
 const openai_namespaceObject = require("@langchain/openai");
+const external_vitest_namespaceObject = require("vitest");
+const modelFactory_cjs_namespaceObject = require("../config/modelFactory.cjs");
 const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
 (0, external_vitest_namespaceObject.beforeEach)(()=>{
     process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
@@ -22,15 +22,54 @@ const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-4o");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
         });
+        (0, external_vitest_namespaceObject.it)("should create a Codex model", ()=>{
+            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("codex:codex-mini-latest");
+            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
+            (0, external_vitest_namespaceObject.expect)(model.useResponsesApi).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(model.zdrEnabled).toBe(true);
+        });
         (0, external_vitest_namespaceObject.it)("should force OpenAI models onto the responses API", ()=>{
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-5.2-codex");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
             (0, external_vitest_namespaceObject.expect)(model.useResponsesApi).toBe(true);
         });
+        (0, external_vitest_namespaceObject.it)("should apply reasoning effort for supported OpenAI reasoning models", ()=>{
+            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-5.2-codex", {
+                reasoningEffort: "high"
+            });
+            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
+            (0, external_vitest_namespaceObject.expect)(model.reasoning).toEqual({
+                effort: "high"
+            });
+        });
+        (0, external_vitest_namespaceObject.it)("should ignore reasoning effort for unsupported OpenAI models", ()=>{
+            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-4o", {
+                reasoningEffort: "medium"
+            });
+            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
+            (0, external_vitest_namespaceObject.expect)(model.reasoning).toBeUndefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should map reasoning effort to anthropic thinking budget", ()=>{
+            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("anthropic:claude-sonnet-4-5", {
+                reasoningEffort: "medium"
+            });
+            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(anthropic_namespaceObject.ChatAnthropic);
+            (0, external_vitest_namespaceObject.expect)(model.thinking).toEqual({
+                type: "enabled",
+                budget_tokens: 4096
+            });
+        });
         (0, external_vitest_namespaceObject.it)("should create an OpenRouter model", ()=>{
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openrouter:openai/gpt-4o");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
         });
+        (0, external_vitest_namespaceObject.it)("should ignore reasoning effort for unsupported providers", ()=>{
+            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openrouter:openai/gpt-5", {
+                reasoningEffort: "high"
+            });
+            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
+            (0, external_vitest_namespaceObject.expect)(model.reasoning).toBeUndefined();
+        });
         (0, external_vitest_namespaceObject.it)("should create a Copilot model", ()=>{
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("copilot:gpt-4o");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
@@ -79,6 +118,7 @@ const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
             const validModels = [
                 "anthropic:claude-opus-4-5",
                 "openai:gpt-4o",
+                "codex:codex-mini-latest",
                 "anthropic:claude-sonnet-4-5-20250929",
                 "openrouter:openai/gpt-4o",
                 "copilot:gpt-4o",
@@ -115,14 +155,16 @@ const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
         (0, external_vitest_namespaceObject.it)("should accept case variations of providers", ()=>{
             const result1 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Anthropic:model");
             const result2 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OPENAI:model");
-            const result3 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Copilot:model");
-            const result4 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("LMStudio:model");
-            const result5 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OLLAMA:model");
+            const result3 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("CODEX:model");
+            const result4 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("Copilot:model");
+            const result5 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("LMStudio:model");
+            const result6 = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString("OLLAMA:model");
             (0, external_vitest_namespaceObject.expect)(result1.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result2.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result3.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result4.valid).toBe(true);
             (0, external_vitest_namespaceObject.expect)(result5.valid).toBe(true);
+            (0, external_vitest_namespaceObject.expect)(result6.valid).toBe(true);
         });
     });
 });

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

@@ -1,7 +1,7 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { ModelFactory } from "../config/modelFactory.js";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatOpenAI } from "@langchain/openai";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { ModelFactory } from "../config/modelFactory.js";
 const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
 beforeEach(()=>{
     process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
@@ -20,15 +20,54 @@ describe("ModelFactory", ()=>{
             const model = ModelFactory.createModel("openai:gpt-4o");
             expect(model).toBeInstanceOf(ChatOpenAI);
         });
+        it("should create a Codex model", ()=>{
+            const model = ModelFactory.createModel("codex:codex-mini-latest");
+            expect(model).toBeInstanceOf(ChatOpenAI);
+            expect(model.useResponsesApi).toBe(true);
+            expect(model.zdrEnabled).toBe(true);
+        });
         it("should force OpenAI models onto the responses API", ()=>{
             const model = ModelFactory.createModel("openai:gpt-5.2-codex");
             expect(model).toBeInstanceOf(ChatOpenAI);
             expect(model.useResponsesApi).toBe(true);
         });
+        it("should apply reasoning effort for supported OpenAI reasoning models", ()=>{
+            const model = ModelFactory.createModel("openai:gpt-5.2-codex", {
+                reasoningEffort: "high"
+            });
+            expect(model).toBeInstanceOf(ChatOpenAI);
+            expect(model.reasoning).toEqual({
+                effort: "high"
+            });
+        });
+        it("should ignore reasoning effort for unsupported OpenAI models", ()=>{
+            const model = ModelFactory.createModel("openai:gpt-4o", {
+                reasoningEffort: "medium"
+            });
+            expect(model).toBeInstanceOf(ChatOpenAI);
+            expect(model.reasoning).toBeUndefined();
+        });
+        it("should map reasoning effort to anthropic thinking budget", ()=>{
+            const model = ModelFactory.createModel("anthropic:claude-sonnet-4-5", {
+                reasoningEffort: "medium"
+            });
+            expect(model).toBeInstanceOf(ChatAnthropic);
+            expect(model.thinking).toEqual({
+                type: "enabled",
+                budget_tokens: 4096
+            });
+        });
         it("should create an OpenRouter model", ()=>{
             const model = ModelFactory.createModel("openrouter:openai/gpt-4o");
             expect(model).toBeInstanceOf(ChatOpenAI);
         });
+        it("should ignore reasoning effort for unsupported providers", ()=>{
+            const model = ModelFactory.createModel("openrouter:openai/gpt-5", {
+                reasoningEffort: "high"
+            });
+            expect(model).toBeInstanceOf(ChatOpenAI);
+            expect(model.reasoning).toBeUndefined();
+        });
         it("should create a Copilot model", ()=>{
             const model = ModelFactory.createModel("copilot:gpt-4o");
             expect(model).toBeInstanceOf(ChatOpenAI);
@@ -77,6 +116,7 @@ describe("ModelFactory", ()=>{
             const validModels = [
                 "anthropic:claude-opus-4-5",
                 "openai:gpt-4o",
+                "codex:codex-mini-latest",
                 "anthropic:claude-sonnet-4-5-20250929",
                 "openrouter:openai/gpt-4o",
                 "copilot:gpt-4o",
@@ -113,14 +153,16 @@ describe("ModelFactory", ()=>{
         it("should accept case variations of providers", ()=>{
             const result1 = ModelFactory.validateModelString("Anthropic:model");
             const result2 = ModelFactory.validateModelString("OPENAI:model");
-            const result3 = ModelFactory.validateModelString("Copilot:model");
-            const result4 = ModelFactory.validateModelString("LMStudio:model");
-            const result5 = ModelFactory.validateModelString("OLLAMA:model");
+            const result3 = ModelFactory.validateModelString("CODEX:model");
+            const result4 = ModelFactory.validateModelString("Copilot:model");
+            const result5 = ModelFactory.validateModelString("LMStudio:model");
+            const result6 = ModelFactory.validateModelString("OLLAMA:model");
             expect(result1.valid).toBe(true);
             expect(result2.valid).toBe(true);
             expect(result3.valid).toBe(true);
             expect(result4.valid).toBe(true);
             expect(result5.valid).toBe(true);
+            expect(result6.valid).toBe(true);
         });
     });
 });

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

@@ -0,0 +1,121 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const terminal_session_manager_cjs_namespaceObject = require("../tools/terminal_session_manager.cjs");
+async function waitForTerminalCompletion(manager, ownerId, sessionId, timeoutMs = 5000) {
+    const started = Date.now();
+    let lastOutput = "";
+    while(Date.now() - started < timeoutMs){
+        const poll = await manager.pollSession({
+            ownerId,
+            sessionId,
+            waitMs: 200,
+            maxOutputChars: 2000
+        });
+        lastOutput += poll.output;
+        if ("running" !== poll.status) return {
+            ...poll,
+            output: lastOutput
+        };
+    }
+    throw new Error(`Timed out waiting for terminal session ${sessionId}`);
+}
+(0, external_vitest_namespaceObject.describe)("TerminalSessionManager", ()=>{
+    (0, external_vitest_namespaceObject.it)("runs commands and returns output", async ()=>{
+        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-a",
+                command: "node -e \"process.stdout.write('hello\\n')\"",
+                cwd: process.cwd(),
+                env: process.env
+            });
+            const finalState = await waitForTerminalCompletion(manager, "owner-a", session.sessionId);
+            (0, external_vitest_namespaceObject.expect)(finalState.output).toContain("hello");
+            (0, external_vitest_namespaceObject.expect)([
+                "completed",
+                "error",
+                "killed",
+                "timed_out"
+            ]).toContain(finalState.status);
+        } finally{
+            manager.dispose();
+        }
+    });
+    (0, external_vitest_namespaceObject.it)("enforces session ownership", async ()=>{
+        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-allowed",
+                command: 'node -e "setTimeout(() => {}, 500)"',
+                cwd: process.cwd(),
+                env: process.env
+            });
+            await (0, external_vitest_namespaceObject.expect)(manager.pollSession({
+                ownerId: "owner-denied",
+                sessionId: session.sessionId,
+                waitMs: 0
+            })).rejects.toThrow("not accessible");
+        } finally{
+            manager.dispose();
+        }
+    });
+    (0, external_vitest_namespaceObject.it)("supports stdin writes and kill", async ()=>{
+        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-b",
+                command: "cat",
+                cwd: process.cwd(),
+                env: process.env
+            });
+            manager.writeSession({
+                ownerId: "owner-b",
+                sessionId: session.sessionId,
+                chars: "ping\n"
+            });
+            const poll = await manager.pollSession({
+                ownerId: "owner-b",
+                sessionId: session.sessionId,
+                waitMs: 1000,
+                maxOutputChars: 2000
+            });
+            (0, external_vitest_namespaceObject.expect)(poll.output).toContain("ping");
+            const killed = manager.killSession({
+                ownerId: "owner-b",
+                sessionId: session.sessionId,
+                signal: "SIGTERM"
+            });
+            (0, external_vitest_namespaceObject.expect)([
+                "running",
+                "killed",
+                "timed_out",
+                "error",
+                "completed"
+            ]).toContain(killed.status);
+        } finally{
+            manager.dispose();
+        }
+    });
+    (0, external_vitest_namespaceObject.it)("drops buffered output when max buffer is exceeded", async ()=>{
+        const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager({
+            maxBufferedCharsPerSession: 32
+        });
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-c",
+                command: "node -e \"process.stdout.write('abcdefghijklmnopqrstuvwxyz0123456789')\"",
+                cwd: process.cwd(),
+                env: process.env
+            });
+            const finalState = await waitForTerminalCompletion(manager, "owner-c", session.sessionId);
+            (0, external_vitest_namespaceObject.expect)(finalState.droppedChars).toBeGreaterThan(0);
+        } 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/terminalSessionManager.test.d.ts

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

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

@@ -0,0 +1,115 @@
+import { describe, expect, it } from "vitest";
+import { TerminalSessionManager } from "../tools/terminal_session_manager.js";
+async function waitForTerminalCompletion(manager, ownerId, sessionId, timeoutMs = 5000) {
+    const started = Date.now();
+    let lastOutput = "";
+    while(Date.now() - started < timeoutMs){
+        const poll = await manager.pollSession({
+            ownerId,
+            sessionId,
+            waitMs: 200,
+            maxOutputChars: 2000
+        });
+        lastOutput += poll.output;
+        if ("running" !== poll.status) return {
+            ...poll,
+            output: lastOutput
+        };
+    }
+    throw new Error(`Timed out waiting for terminal session ${sessionId}`);
+}
+describe("TerminalSessionManager", ()=>{
+    it("runs commands and returns output", async ()=>{
+        const manager = new TerminalSessionManager();
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-a",
+                command: "node -e \"process.stdout.write('hello\\n')\"",
+                cwd: process.cwd(),
+                env: process.env
+            });
+            const finalState = await waitForTerminalCompletion(manager, "owner-a", session.sessionId);
+            expect(finalState.output).toContain("hello");
+            expect([
+                "completed",
+                "error",
+                "killed",
+                "timed_out"
+            ]).toContain(finalState.status);
+        } finally{
+            manager.dispose();
+        }
+    });
+    it("enforces session ownership", async ()=>{
+        const manager = new TerminalSessionManager();
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-allowed",
+                command: 'node -e "setTimeout(() => {}, 500)"',
+                cwd: process.cwd(),
+                env: process.env
+            });
+            await expect(manager.pollSession({
+                ownerId: "owner-denied",
+                sessionId: session.sessionId,
+                waitMs: 0
+            })).rejects.toThrow("not accessible");
+        } finally{
+            manager.dispose();
+        }
+    });
+    it("supports stdin writes and kill", async ()=>{
+        const manager = new TerminalSessionManager();
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-b",
+                command: "cat",
+                cwd: process.cwd(),
+                env: process.env
+            });
+            manager.writeSession({
+                ownerId: "owner-b",
+                sessionId: session.sessionId,
+                chars: "ping\n"
+            });
+            const poll = await manager.pollSession({
+                ownerId: "owner-b",
+                sessionId: session.sessionId,
+                waitMs: 1000,
+                maxOutputChars: 2000
+            });
+            expect(poll.output).toContain("ping");
+            const killed = manager.killSession({
+                ownerId: "owner-b",
+                sessionId: session.sessionId,
+                signal: "SIGTERM"
+            });
+            expect([
+                "running",
+                "killed",
+                "timed_out",
+                "error",
+                "completed"
+            ]).toContain(killed.status);
+        } finally{
+            manager.dispose();
+        }
+    });
+    it("drops buffered output when max buffer is exceeded", async ()=>{
+        const manager = new TerminalSessionManager({
+            maxBufferedCharsPerSession: 32
+        });
+        try {
+            const session = manager.startSession({
+                ownerId: "owner-c",
+                command: "node -e \"process.stdout.write('abcdefghijklmnopqrstuvwxyz0123456789')\"",
+                cwd: process.cwd(),
+                env: process.env
+            });
+            const finalState = await waitForTerminalCompletion(manager, "owner-c", session.sessionId);
+            expect(finalState.droppedChars).toBeGreaterThan(0);
+        } finally{
+            manager.dispose();
+        }
+    });
+});

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

@@ -1,10 +1,11 @@
 "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_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
 const toolRegistry_cjs_namespaceObject = require("../config/toolRegistry.cjs");
+const terminal_session_manager_cjs_namespaceObject = require("../tools/terminal_session_manager.cjs");
 (0, external_vitest_namespaceObject.describe)("Tool Registry", ()=>{
     (0, external_vitest_namespaceObject.describe)("createTool", ()=>{
         (0, external_vitest_namespaceObject.it)("should create internet_search tool", ()=>{
@@ -35,6 +36,15 @@ const toolRegistry_cjs_namespaceObject = require("../config/toolRegistry.cjs");
             (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
             (0, external_vitest_namespaceObject.expect)(tool?.name).toBe("command_execute");
         });
+        (0, external_vitest_namespaceObject.it)("should create terminal tools", ()=>{
+            const manager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
+            const terminalTool = (0, toolRegistry_cjs_namespaceObject.createTool)("background_terminal", {
+                terminalOwnerId: "owner-1",
+                terminalSessionManager: manager
+            });
+            (0, external_vitest_namespaceObject.expect)(terminalTool?.name).toBe("background_terminal");
+            manager.dispose();
+        });
         (0, external_vitest_namespaceObject.it)("should execute command tools in executionWorkspace when provided", async ()=>{
             const executionWorkspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-tool-workspace-"));
             const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("command_execute", {
@@ -42,6 +52,7 @@ const toolRegistry_cjs_namespaceObject = require("../config/toolRegistry.cjs");
                 executionWorkspace
             });
             (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
+            if (!tool) throw new Error("Expected command_execute tool to be created");
             const result = await tool.invoke({
                 command: 'node -e "process.stdout.write(process.cwd())"'
             });
@@ -106,6 +117,7 @@ const toolRegistry_cjs_namespaceObject = require("../config/toolRegistry.cjs");
                 "internet_search",
                 "web_crawler",
                 "command_execute",
+                "background_terminal",
                 "think",
                 "code_search",
                 "git_status",

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

@@ -1,8 +1,9 @@
-import { describe, expect, it } from "vitest";
 import { mkdtempSync } from "node:fs";
-import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
 import { createTool, createTools, getAvailableTools } from "../config/toolRegistry.js";
+import { TerminalSessionManager } from "../tools/terminal_session_manager.js";
 describe("Tool Registry", ()=>{
     describe("createTool", ()=>{
         it("should create internet_search tool", ()=>{
@@ -33,6 +34,15 @@ describe("Tool Registry", ()=>{
             expect(tool).not.toBeNull();
             expect(tool?.name).toBe("command_execute");
         });
+        it("should create terminal tools", ()=>{
+            const manager = new TerminalSessionManager();
+            const terminalTool = createTool("background_terminal", {
+                terminalOwnerId: "owner-1",
+                terminalSessionManager: manager
+            });
+            expect(terminalTool?.name).toBe("background_terminal");
+            manager.dispose();
+        });
         it("should execute command tools in executionWorkspace when provided", async ()=>{
             const executionWorkspace = mkdtempSync(join(tmpdir(), "wingman-tool-workspace-"));
             const tool = createTool("command_execute", {
@@ -40,6 +50,7 @@ describe("Tool Registry", ()=>{
                 executionWorkspace
             });
             expect(tool).not.toBeNull();
+            if (!tool) throw new Error("Expected command_execute tool to be created");
             const result = await tool.invoke({
                 command: 'node -e "process.stdout.write(process.cwd())"'
             });
@@ -104,6 +115,7 @@ describe("Tool Registry", ()=>{
                 "internet_search",
                 "web_crawler",
                 "command_execute",
+                "background_terminal",
                 "think",
                 "code_search",
                 "git_status",

package/dist/agent/tools/background_terminal.cjs

@@ -0,0 +1,128 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createBackgroundTerminalTool: ()=>createBackgroundTerminalTool
+});
+const external_langchain_namespaceObject = require("langchain");
+const external_zod_namespaceObject = require("zod");
+const external_command_execute_cjs_namespaceObject = require("./command_execute.cjs");
+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 = external_command_execute_cjs_namespaceObject.DEFAULT_BLOCKED_COMMANDS, allowScriptExecution = true, commandTimeout = 300000 } = options;
+    return (0, external_langchain_namespaceObject.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: external_zod_namespaceObject.object({
+            command: external_zod_namespaceObject.string().optional().describe("Command to start a new terminal session"),
+            session_id: external_zod_namespaceObject.string().optional().describe("Existing terminal session id for poll/write"),
+            chars: external_zod_namespaceObject.string().optional().default("").describe("Optional stdin text to write before polling"),
+            wait_ms: external_zod_namespaceObject.number().min(0).max(30000).optional().default(1000).describe("How long to wait for output before returning"),
+            max_output_chars: external_zod_namespaceObject.number().min(1).max(200000).optional().default(8000).describe("Maximum output characters to return")
+        })
+    });
+};
+exports.createBackgroundTerminalTool = __webpack_exports__.createBackgroundTerminalTool;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBackgroundTerminalTool"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});