@wingman-ai/gateway 0.2.3 → 0.2.5

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

@@ -23,16 +23,51 @@ describe("ModelFactory", ()=>{
         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);

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
+});

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

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

package/dist/agent/tools/background_terminal.js

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

package/dist/agent/tools/code_search.cjs

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