@wingman-ai/gateway 0.2.3 → 0.2.4

package/dist/agent/config/agentLoader.js

@@ -1,10 +1,10 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { load } from "js-yaml";
+import { createLogger } from "../../logger.js";
 import { WingmanDirectory, validateAgentConfig } from "./agentConfig.js";
-import { UI_TOOL_NAMES, createTools } from "./toolRegistry.js";
 import { ModelFactory } from "./modelFactory.js";
-import { createLogger } from "../../logger.js";
+import { UI_TOOL_NAMES, createTools } from "./toolRegistry.js";
 function _define_property(obj, key, value) {
     if (key in obj) Object.defineProperty(obj, key, {
         value: value,
@@ -31,6 +31,7 @@ const buildPromptRefinementInstructions = (instructionsPath)=>[
         "Prompt Refinement:",
         `- Maintain a durable overlay at ${instructionsPath} for stable preferences and corrections.`,
         "- Read it at the start of each session and follow it in addition to this system prompt.",
+        "- Treat that overlay as secondary preference memory; if it conflicts with role, safety, or execution rules in this system prompt, follow this system prompt.",
         '- Only update it when the user gives explicit, lasting feedback (e.g., "always", "never", "prefer").',
         "- Keep entries short, stable, and avoid task-specific details.",
         "- If the file doesn't exist, create it with a short header and bullet list."
@@ -98,12 +99,18 @@ class AgentLoader {
         }
     }
     normalizeAgentConfig(config) {
+        const normalizeReasoningEffort = (target)=>{
+            if (void 0 === target.reasoningEffort && void 0 !== target.thinkingEffort) target.reasoningEffort = target.thinkingEffort;
+            if ("thinkingEffort" in target) delete target.thinkingEffort;
+        };
+        normalizeReasoningEffort(config);
         if (config.subagents && !config.subAgents) {
             config.subAgents = config.subagents;
             delete config.subagents;
         }
-        if (Array.isArray(config.subAgents)) {
-            for (const subagent of config.subAgents)if (subagent?.subagents && !subagent.subAgents) {
+        if (Array.isArray(config.subAgents)) for (const subagent of config.subAgents){
+            normalizeReasoningEffort(subagent);
+            if (subagent?.subagents && !subagent.subAgents) {
                 subagent.subAgents = subagent.subagents;
                 delete subagent.subagents;
             }
@@ -196,7 +203,8 @@ class AgentLoader {
                 searchConfig: this.wingmanConfig?.search,
                 mcpConfigs,
                 skillsDirectory,
-                dynamicUiEnabled
+                dynamicUiEnabled,
+                ...this.runtimeToolOptions
             };
         };
         if (config.tools && config.tools.length > 0) agent.tools = await createTools(config.tools, buildToolOptions(config));
@@ -212,12 +220,16 @@ class AgentLoader {
         if (config.mcp) agent.mcpConfig = config.mcp;
         if (config.mcpUseGlobal) agent.mcpUseGlobal = true;
         if (config.model) try {
-            agent.model = ModelFactory.createModel(config.model);
+            agent.model = ModelFactory.createModel(config.model, {
+                reasoningEffort: config.reasoningEffort,
+                ownerLabel: `Agent "${config.name}"`
+            });
             logger.info(`Agent "${config.name}" using model: ${config.model}`);
         } catch (error) {
             logger.error(`Failed to create model for agent "${config.name}": ${error}`);
             logger.info(`Agent "${config.name}" will use default model`);
         }
+        else if (config.reasoningEffort) logger.warn(`Agent "${config.name}" set reasoningEffort="${config.reasoningEffort}" but has no model override. Ignoring.`);
         if (config.subAgents) {
             const subagents = [];
             for (const subagent of config.subAgents){
@@ -241,26 +253,32 @@ class AgentLoader {
                     ];
                 } else sub.tools = subUiTools;
                 if (subagent.model) try {
-                    sub.model = ModelFactory.createModel(subagent.model);
+                    sub.model = ModelFactory.createModel(subagent.model, {
+                        reasoningEffort: subagent.reasoningEffort,
+                        ownerLabel: `Subagent "${subagent.name}"`
+                    });
                     logger.info(`Subagent "${subagent.name}" using model: ${subagent.model}`);
                 } catch (error) {
                     logger.error(`Failed to create model for subagent "${subagent.name}": ${error}`);
                 }
+                else if (subagent.reasoningEffort) logger.warn(`Subagent "${subagent.name}" set reasoningEffort="${subagent.reasoningEffort}" but has no model override. Ignoring.`);
                 subagents.push(sub);
             }
             agent.subagents = subagents;
         }
         return agent;
     }
-    constructor(configDir = WingmanDirectory, workspace = process.cwd(), wingmanConfig, executionWorkspace = workspace){
+    constructor(configDir = WingmanDirectory, workspace = process.cwd(), wingmanConfig, executionWorkspace = workspace, runtimeToolOptions = {}){
         _define_property(this, "configDir", void 0);
         _define_property(this, "workspace", void 0);
         _define_property(this, "wingmanConfig", void 0);
         _define_property(this, "executionWorkspace", void 0);
+        _define_property(this, "runtimeToolOptions", void 0);
         this.configDir = configDir;
         this.workspace = workspace;
         this.wingmanConfig = wingmanConfig;
         this.executionWorkspace = executionWorkspace;
+        this.runtimeToolOptions = runtimeToolOptions;
     }
 }
 export { AgentLoader };

package/dist/agent/config/modelFactory.cjs

@@ -35,8 +35,16 @@ const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs
 const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
 const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+const OPENAI_REASONING_MODEL_PATTERN = /(^|[/:._-])(gpt-5|o1|o3|o4|codex)([/:._-]|$)/i;
+const ANTHROPIC_THINKING_MODEL_PATTERN = /claude-(3-7|sonnet-4|opus-4|4)/i;
+const ANTHROPIC_THINKING_BUDGETS = {
+    minimal: 1024,
+    low: 2048,
+    medium: 4096,
+    high: 8192
+};
 class ModelFactory {
-    static createModel(modelString) {
+    static createModel(modelString, options = {}) {
         const separatorIndex = modelString.indexOf(":");
         if (-1 === separatorIndex) throw new Error(`Invalid model format: "${modelString}". Expected format: "provider:model-name"`);
         const provider = modelString.slice(0, separatorIndex);
@@ -51,21 +59,21 @@ class ModelFactory {
         logger.debug(`Creating model: ${normalizedProvider}:${model}`);
         switch(providerSpec.name){
             case "anthropic":
-                return ModelFactory.createAnthropicModel(model);
+                return ModelFactory.createAnthropicModel(model, options);
             case "openai":
-                return ModelFactory.createOpenAIModel(model);
+                return ModelFactory.createOpenAIModel(model, options);
             case "codex":
-                return ModelFactory.createCodexModel(model);
+                return ModelFactory.createCodexModel(model, options);
             case "openrouter":
-                return ModelFactory.createOpenRouterModel(model);
+                return ModelFactory.createOpenRouterModel(model, options);
             case "copilot":
-                return ModelFactory.createCopilotModel(model);
+                return ModelFactory.createCopilotModel(model, options);
             case "xai":
-                return ModelFactory.createXAIModel(model);
+                return ModelFactory.createXAIModel(model, options);
             case "lmstudio":
-                return ModelFactory.createLMStudioModel(model);
+                return ModelFactory.createLMStudioModel(model, options);
             case "ollama":
-                return ModelFactory.createOllamaModel(model);
+                return ModelFactory.createOllamaModel(model, options);
         }
     }
     static validateModelString(modelString) {
@@ -93,16 +101,17 @@ class ModelFactory {
             valid: true
         };
     }
-    static createAnthropicModel(model) {
+    static createAnthropicModel(model, options) {
         const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("anthropic").token;
         const params = {
             model,
             temperature: 1
         };
         if (token) params.apiKey = token;
+        ModelFactory.applyAnthropicThinkingEffort(params, "anthropic", model, options);
         return new anthropic_namespaceObject.ChatAnthropic(params);
     }
-    static createOpenAIModel(model) {
+    static createOpenAIModel(model, options) {
         const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("openai").token;
         const params = {
             model,
@@ -110,15 +119,17 @@ class ModelFactory {
             useResponsesApi: true
         };
         if (token) params.apiKey = token;
+        ModelFactory.applyOpenAIReasoningEffort(params, "openai", model, options);
         return new openai_namespaceObject.ChatOpenAI(params);
     }
-    static createCodexModel(model) {
+    static createCodexModel(model, options) {
         const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("codex");
         const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("codex").token;
         const codexAuth = (0, codex_cjs_namespaceObject.resolveCodexAuthFromFile)();
-        return new openai_namespaceObject.ChatOpenAI({
+        const params = {
             model,
             useResponsesApi: true,
+            zdrEnabled: true,
             apiKey: token ?? "codex",
             configuration: {
                 baseURL: provider?.baseURL,
@@ -127,23 +138,27 @@ class ModelFactory {
                     fallbackAccountId: codexAuth.accountId
                 })
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "codex", model, options);
+        return new openai_namespaceObject.ChatOpenAI(params);
     }
-    static createOpenRouterModel(model) {
+    static createOpenRouterModel(model, options) {
         const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("openrouter").token ?? "";
         const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("openrouter");
-        return new openai_namespaceObject.ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: token,
             configuration: {
                 baseURL: provider?.baseURL
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "openrouter", model, options);
+        return new openai_namespaceObject.ChatOpenAI(params);
     }
-    static createCopilotModel(model) {
+    static createCopilotModel(model, options) {
         const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("copilot");
-        return new openai_namespaceObject.ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: "copilot",
@@ -151,42 +166,77 @@ class ModelFactory {
                 baseURL: provider?.baseURL,
                 fetch: (0, copilot_cjs_namespaceObject.createCopilotFetch)()
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "copilot", model, options);
+        return new openai_namespaceObject.ChatOpenAI(params);
     }
-    static createXAIModel(model) {
+    static createXAIModel(model, options) {
         const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("xai").token;
         const params = {
             model,
             temperature: 1
         };
         if (token) params.apiKey = token;
+        if (options.reasoningEffort) ModelFactory.warnUnsupportedReasoningEffort("xai", model, options.reasoningEffort, options.ownerLabel);
         return new xai_namespaceObject.ChatXAI(params);
     }
-    static createLMStudioModel(model) {
+    static createLMStudioModel(model, options) {
         const tokenResult = (0, credentials_cjs_namespaceObject.resolveProviderToken)("lmstudio");
         const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("lmstudio");
         const apiKey = tokenResult.token ?? "lm-studio";
-        return new openai_namespaceObject.ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: apiKey,
             configuration: {
                 baseURL: provider?.baseURL
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "lmstudio", model, options);
+        return new openai_namespaceObject.ChatOpenAI(params);
     }
-    static createOllamaModel(model) {
+    static createOllamaModel(model, options) {
         const tokenResult = (0, credentials_cjs_namespaceObject.resolveProviderToken)("ollama");
         const provider = (0, registry_cjs_namespaceObject.getProviderSpec)("ollama");
         const apiKey = tokenResult.token ?? "ollama";
-        return new openai_namespaceObject.ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: apiKey,
             configuration: {
                 baseURL: provider?.baseURL
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "ollama", model, options);
+        return new openai_namespaceObject.ChatOpenAI(params);
+    }
+    static applyOpenAIReasoningEffort(params, provider, model, options) {
+        const effort = options.reasoningEffort;
+        if (!effort) return;
+        if (!ModelFactory.supportsOpenAIReasoningEffort(provider, model)) return void ModelFactory.warnUnsupportedReasoningEffort(provider, model, effort, options.ownerLabel);
+        params.reasoning = {
+            effort
+        };
+    }
+    static applyAnthropicThinkingEffort(params, provider, model, options) {
+        const effort = options.reasoningEffort;
+        if (!effort) return;
+        if (!ModelFactory.supportsAnthropicThinking(model)) return void ModelFactory.warnUnsupportedReasoningEffort(provider, model, effort, options.ownerLabel);
+        params.thinking = {
+            type: "enabled",
+            budget_tokens: ANTHROPIC_THINKING_BUDGETS[effort]
+        };
+    }
+    static supportsOpenAIReasoningEffort(provider, model) {
+        if ("openai" !== provider && "codex" !== provider) return false;
+        return OPENAI_REASONING_MODEL_PATTERN.test(model.trim());
+    }
+    static supportsAnthropicThinking(model) {
+        return ANTHROPIC_THINKING_MODEL_PATTERN.test(model.trim().toLowerCase());
+    }
+    static warnUnsupportedReasoningEffort(provider, model, effort, ownerLabel) {
+        const prefix = ownerLabel ? `${ownerLabel}: ` : "";
+        logger.warn(`${prefix}model "${provider}:${model}" does not support reasoningEffort="${effort}". Ignoring and continuing.`);
     }
 }
 exports.ModelFactory = __webpack_exports__.ModelFactory;

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

@@ -1,4 +1,9 @@
 import type { BaseLanguageModel, BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import type { ReasoningEffort } from "./agentConfig.js";
+export type ModelCreationOptions = {
+    reasoningEffort?: ReasoningEffort;
+    ownerLabel?: string;
+};
 /**
  * Create a LangChain model from a model string
  *
@@ -16,7 +21,7 @@ export declare class ModelFactory {
     /**
      * Parse and create a model from a string specification
      */
-    static createModel(modelString: string): string | BaseLanguageModel<any, BaseLanguageModelCallOptions> | undefined;
+    static createModel(modelString: string, options?: ModelCreationOptions): string | BaseLanguageModel<any, BaseLanguageModelCallOptions> | undefined;
     /**
      * Validate model string format without creating the model
      */
@@ -32,4 +37,9 @@ export declare class ModelFactory {
     private static createXAIModel;
     private static createLMStudioModel;
     private static createOllamaModel;
+    private static applyOpenAIReasoningEffort;
+    private static applyAnthropicThinkingEffort;
+    private static supportsOpenAIReasoningEffort;
+    private static supportsAnthropicThinking;
+    private static warnUnsupportedReasoningEffort;
 }

package/dist/agent/config/modelFactory.js

@@ -7,8 +7,16 @@ import { resolveProviderToken } from "../../providers/credentials.js";
 import { getProviderSpec, listProviderSpecs, normalizeProviderName } from "../../providers/registry.js";
 import { createLogger } from "../../logger.js";
 const logger = createLogger();
+const OPENAI_REASONING_MODEL_PATTERN = /(^|[/:._-])(gpt-5|o1|o3|o4|codex)([/:._-]|$)/i;
+const ANTHROPIC_THINKING_MODEL_PATTERN = /claude-(3-7|sonnet-4|opus-4|4)/i;
+const ANTHROPIC_THINKING_BUDGETS = {
+    minimal: 1024,
+    low: 2048,
+    medium: 4096,
+    high: 8192
+};
 class ModelFactory {
-    static createModel(modelString) {
+    static createModel(modelString, options = {}) {
         const separatorIndex = modelString.indexOf(":");
         if (-1 === separatorIndex) throw new Error(`Invalid model format: "${modelString}". Expected format: "provider:model-name"`);
         const provider = modelString.slice(0, separatorIndex);
@@ -23,21 +31,21 @@ class ModelFactory {
         logger.debug(`Creating model: ${normalizedProvider}:${model}`);
         switch(providerSpec.name){
             case "anthropic":
-                return ModelFactory.createAnthropicModel(model);
+                return ModelFactory.createAnthropicModel(model, options);
             case "openai":
-                return ModelFactory.createOpenAIModel(model);
+                return ModelFactory.createOpenAIModel(model, options);
             case "codex":
-                return ModelFactory.createCodexModel(model);
+                return ModelFactory.createCodexModel(model, options);
             case "openrouter":
-                return ModelFactory.createOpenRouterModel(model);
+                return ModelFactory.createOpenRouterModel(model, options);
             case "copilot":
-                return ModelFactory.createCopilotModel(model);
+                return ModelFactory.createCopilotModel(model, options);
             case "xai":
-                return ModelFactory.createXAIModel(model);
+                return ModelFactory.createXAIModel(model, options);
             case "lmstudio":
-                return ModelFactory.createLMStudioModel(model);
+                return ModelFactory.createLMStudioModel(model, options);
             case "ollama":
-                return ModelFactory.createOllamaModel(model);
+                return ModelFactory.createOllamaModel(model, options);
         }
     }
     static validateModelString(modelString) {
@@ -65,16 +73,17 @@ class ModelFactory {
             valid: true
         };
     }
-    static createAnthropicModel(model) {
+    static createAnthropicModel(model, options) {
         const token = resolveProviderToken("anthropic").token;
         const params = {
             model,
             temperature: 1
         };
         if (token) params.apiKey = token;
+        ModelFactory.applyAnthropicThinkingEffort(params, "anthropic", model, options);
         return new ChatAnthropic(params);
     }
-    static createOpenAIModel(model) {
+    static createOpenAIModel(model, options) {
         const token = resolveProviderToken("openai").token;
         const params = {
             model,
@@ -82,15 +91,17 @@ class ModelFactory {
             useResponsesApi: true
         };
         if (token) params.apiKey = token;
+        ModelFactory.applyOpenAIReasoningEffort(params, "openai", model, options);
         return new ChatOpenAI(params);
     }
-    static createCodexModel(model) {
+    static createCodexModel(model, options) {
         const provider = getProviderSpec("codex");
         const token = resolveProviderToken("codex").token;
         const codexAuth = resolveCodexAuthFromFile();
-        return new ChatOpenAI({
+        const params = {
             model,
             useResponsesApi: true,
+            zdrEnabled: true,
             apiKey: token ?? "codex",
             configuration: {
                 baseURL: provider?.baseURL,
@@ -99,23 +110,27 @@ class ModelFactory {
                     fallbackAccountId: codexAuth.accountId
                 })
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "codex", model, options);
+        return new ChatOpenAI(params);
     }
-    static createOpenRouterModel(model) {
+    static createOpenRouterModel(model, options) {
         const token = resolveProviderToken("openrouter").token ?? "";
         const provider = getProviderSpec("openrouter");
-        return new ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: token,
             configuration: {
                 baseURL: provider?.baseURL
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "openrouter", model, options);
+        return new ChatOpenAI(params);
     }
-    static createCopilotModel(model) {
+    static createCopilotModel(model, options) {
         const provider = getProviderSpec("copilot");
-        return new ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: "copilot",
@@ -123,42 +138,77 @@ class ModelFactory {
                 baseURL: provider?.baseURL,
                 fetch: createCopilotFetch()
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "copilot", model, options);
+        return new ChatOpenAI(params);
     }
-    static createXAIModel(model) {
+    static createXAIModel(model, options) {
         const token = resolveProviderToken("xai").token;
         const params = {
             model,
             temperature: 1
         };
         if (token) params.apiKey = token;
+        if (options.reasoningEffort) ModelFactory.warnUnsupportedReasoningEffort("xai", model, options.reasoningEffort, options.ownerLabel);
         return new ChatXAI(params);
     }
-    static createLMStudioModel(model) {
+    static createLMStudioModel(model, options) {
         const tokenResult = resolveProviderToken("lmstudio");
         const provider = getProviderSpec("lmstudio");
         const apiKey = tokenResult.token ?? "lm-studio";
-        return new ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: apiKey,
             configuration: {
                 baseURL: provider?.baseURL
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "lmstudio", model, options);
+        return new ChatOpenAI(params);
     }
-    static createOllamaModel(model) {
+    static createOllamaModel(model, options) {
         const tokenResult = resolveProviderToken("ollama");
         const provider = getProviderSpec("ollama");
         const apiKey = tokenResult.token ?? "ollama";
-        return new ChatOpenAI({
+        const params = {
             model,
             temperature: 1,
             apiKey: apiKey,
             configuration: {
                 baseURL: provider?.baseURL
             }
-        });
+        };
+        ModelFactory.applyOpenAIReasoningEffort(params, "ollama", model, options);
+        return new ChatOpenAI(params);
+    }
+    static applyOpenAIReasoningEffort(params, provider, model, options) {
+        const effort = options.reasoningEffort;
+        if (!effort) return;
+        if (!ModelFactory.supportsOpenAIReasoningEffort(provider, model)) return void ModelFactory.warnUnsupportedReasoningEffort(provider, model, effort, options.ownerLabel);
+        params.reasoning = {
+            effort
+        };
+    }
+    static applyAnthropicThinkingEffort(params, provider, model, options) {
+        const effort = options.reasoningEffort;
+        if (!effort) return;
+        if (!ModelFactory.supportsAnthropicThinking(model)) return void ModelFactory.warnUnsupportedReasoningEffort(provider, model, effort, options.ownerLabel);
+        params.thinking = {
+            type: "enabled",
+            budget_tokens: ANTHROPIC_THINKING_BUDGETS[effort]
+        };
+    }
+    static supportsOpenAIReasoningEffort(provider, model) {
+        if ("openai" !== provider && "codex" !== provider) return false;
+        return OPENAI_REASONING_MODEL_PATTERN.test(model.trim());
+    }
+    static supportsAnthropicThinking(model) {
+        return ANTHROPIC_THINKING_MODEL_PATTERN.test(model.trim().toLowerCase());
+    }
+    static warnUnsupportedReasoningEffort(provider, model, effort, ownerLabel) {
+        const prefix = ownerLabel ? `${ownerLabel}: ` : "";
+        logger.warn(`${prefix}model "${provider}:${model}" does not support reasoningEffort="${effort}". Ignoring and continuing.`);
     }
 }
 export { ModelFactory };

package/dist/agent/config/toolRegistry.cjs

@@ -29,14 +29,16 @@ __webpack_require__.d(__webpack_exports__, {
     getAvailableTools: ()=>getAvailableTools,
     createTool: ()=>createTool
 });
-const internet_search_cjs_namespaceObject = require("../tools/internet_search.cjs");
-const web_crawler_cjs_namespaceObject = require("../tools/web_crawler.cjs");
-const command_execute_cjs_namespaceObject = require("../tools/command_execute.cjs");
-const think_cjs_namespaceObject = require("../tools/think.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const background_terminal_cjs_namespaceObject = require("../tools/background_terminal.cjs");
 const code_search_cjs_namespaceObject = require("../tools/code_search.cjs");
+const command_execute_cjs_namespaceObject = require("../tools/command_execute.cjs");
 const git_status_cjs_namespaceObject = require("../tools/git_status.cjs");
+const internet_search_cjs_namespaceObject = require("../tools/internet_search.cjs");
+const terminal_session_manager_cjs_namespaceObject = require("../tools/terminal_session_manager.cjs");
+const think_cjs_namespaceObject = require("../tools/think.cjs");
 const ui_registry_cjs_namespaceObject = require("../tools/ui_registry.cjs");
-const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const web_crawler_cjs_namespaceObject = require("../tools/web_crawler.cjs");
 const external_mcpClientManager_cjs_namespaceObject = require("./mcpClientManager.cjs");
 const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
 const UI_TOOL_NAMES = [
@@ -45,7 +47,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 = (0, terminal_session_manager_cjs_namespaceObject.getSharedTerminalSessionManager)(), searchConfig = {
         provider: "duckduckgo",
         maxResults: 5
     }, skillsDirectory = "skills", dynamicUiEnabled = true } = options;
@@ -65,6 +67,16 @@ function createTool(name, options = {}) {
             return web_crawler_cjs_namespaceObject.webCrawler;
         case "command_execute":
             return (0, command_execute_cjs_namespaceObject.createCommandExecuteTool)(runtimeWorkspace, process.env, blockedCommands, allowScriptExecution, timeout);
+        case "background_terminal":
+            return (0, background_terminal_cjs_namespaceObject.createBackgroundTerminalTool)({
+                workspace: runtimeWorkspace,
+                ownerId: terminalOwnerId,
+                sessionManager: terminalSessionManager,
+                envVariables: process.env,
+                blockedCommands,
+                allowScriptExecution,
+                commandTimeout: timeout
+            });
         case "think":
             return (0, think_cjs_namespaceObject.createThinkingTool)();
         case "code_search":
@@ -108,6 +120,7 @@ function getAvailableTools() {
         "internet_search",
         "web_crawler",
         "command_execute",
+        "background_terminal",
         "think",
         "code_search",
         "git_status",

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

@@ -1,13 +1,16 @@
 import type { StructuredTool } from "@langchain/core/tools";
-import type { AvailableToolName } from "./agentConfig.js";
-import type { SearchConfig } from "../../cli/config/schema.js";
 import type { MCPServersConfig } from "@/types/mcp.js";
+import type { SearchConfig } from "../../cli/config/schema.js";
+import { type TerminalSessionManager } from "../tools/terminal_session_manager.js";
+import type { AvailableToolName } from "./agentConfig.js";
 export interface ToolOptions {
     workspace?: string;
     executionWorkspace?: string;
     blockedCommands?: string[];
     allowScriptExecution?: boolean;
     timeout?: number;
+    terminalOwnerId?: string;
+    terminalSessionManager?: TerminalSessionManager;
     searchConfig?: SearchConfig;
     mcpConfigs?: MCPServersConfig[];
     skillsDirectory?: string;