@wingman-ai/gateway 0.5.2 → 0.5.4

package/dist/agent/config/agentConfig.cjs

@@ -40,6 +40,10 @@ const AvailableToolNames = external_zod_namespaceObject["enum"]([
     "internet_search",
     "web_crawler",
     "browser_control",
+    "browser_session_start",
+    "browser_session_action",
+    "browser_session_close",
+    "browser_session_list",
     "command_execute",
     "background_terminal",
     "node_notify",

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

@@ -7,6 +7,10 @@ export declare const AvailableToolNames: z.ZodEnum<{
     internet_search: "internet_search";
     web_crawler: "web_crawler";
     browser_control: "browser_control";
+    browser_session_start: "browser_session_start";
+    browser_session_action: "browser_session_action";
+    browser_session_close: "browser_session_close";
+    browser_session_list: "browser_session_list";
     command_execute: "command_execute";
     background_terminal: "background_terminal";
     node_notify: "node_notify";
@@ -44,6 +48,10 @@ export declare const AgentConfigSchema: z.ZodObject<{
         internet_search: "internet_search";
         web_crawler: "web_crawler";
         browser_control: "browser_control";
+        browser_session_start: "browser_session_start";
+        browser_session_action: "browser_session_action";
+        browser_session_close: "browser_session_close";
+        browser_session_list: "browser_session_list";
         command_execute: "command_execute";
         background_terminal: "background_terminal";
         node_notify: "node_notify";
@@ -150,6 +158,10 @@ export declare const AgentConfigSchema: z.ZodObject<{
             internet_search: "internet_search";
             web_crawler: "web_crawler";
             browser_control: "browser_control";
+            browser_session_start: "browser_session_start";
+            browser_session_action: "browser_session_action";
+            browser_session_close: "browser_session_close";
+            browser_session_list: "browser_session_list";
             command_execute: "command_execute";
             background_terminal: "background_terminal";
             node_notify: "node_notify";

package/dist/agent/config/agentConfig.js

@@ -7,6 +7,10 @@ const AvailableToolNames = external_zod_enum([
     "internet_search",
     "web_crawler",
     "browser_control",
+    "browser_session_start",
+    "browser_session_action",
+    "browser_session_close",
+    "browser_session_list",
     "command_execute",
     "background_terminal",
     "node_notify",

package/dist/agent/config/toolRegistry.cjs

@@ -33,6 +33,8 @@ __webpack_require__.d(__webpack_exports__, {
 const external_logger_cjs_namespaceObject = require("../../logger.cjs");
 const background_terminal_cjs_namespaceObject = require("../tools/background_terminal.cjs");
 const browser_control_cjs_namespaceObject = require("../tools/browser_control.cjs");
+const browser_session_cjs_namespaceObject = require("../tools/browser_session.cjs");
+const browser_session_manager_cjs_namespaceObject = require("../tools/browser_session_manager.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");
@@ -54,7 +56,7 @@ const NODE_TOOL_NAMES = [
     "node_run"
 ];
 function createTool(name, options = {}) {
-    const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, terminalOwnerId = "default", terminalSessionManager = (0, terminal_session_manager_cjs_namespaceObject.getSharedTerminalSessionManager)(), searchConfig = {
+    const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, terminalOwnerId = "default", terminalSessionManager = (0, terminal_session_manager_cjs_namespaceObject.getSharedTerminalSessionManager)(), browserSessionOwnerId = "default", browserSessionManager = (0, browser_session_manager_cjs_namespaceObject.getSharedBrowserSessionManager)(), searchConfig = {
         provider: "duckduckgo",
         maxResults: 5
     }, skillsDirectory = "skills", dynamicUiEnabled = true } = options;
@@ -99,6 +101,74 @@ function createTool(name, options = {}) {
                 allowScriptExecution,
                 commandTimeout: timeout
             });
+        case "browser_session_start":
+            return (0, browser_session_cjs_namespaceObject.createBrowserSessionStartTool)({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
+        case "browser_session_action":
+            return (0, browser_session_cjs_namespaceObject.createBrowserSessionActionTool)({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
+        case "browser_session_close":
+            return (0, browser_session_cjs_namespaceObject.createBrowserSessionCloseTool)({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
+        case "browser_session_list":
+            return (0, browser_session_cjs_namespaceObject.createBrowserSessionListTool)({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
         case "node_notify":
             return (0, node_invoke_cjs_namespaceObject.createNodeNotifyTool)({
                 nodeInvoker: options.nodeInvoker,
@@ -154,6 +224,10 @@ function getAvailableTools() {
         "internet_search",
         "web_crawler",
         "browser_control",
+        "browser_session_start",
+        "browser_session_action",
+        "browser_session_close",
+        "browser_session_list",
         "command_execute",
         "background_terminal",
         ...NODE_TOOL_NAMES,

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

@@ -1,6 +1,7 @@
 import type { StructuredTool } from "@langchain/core/tools";
 import type { MCPServersConfig } from "@/types/mcp.js";
 import type { SearchConfig } from "../../cli/config/schema.js";
+import { type BrowserSessionManager } from "../tools/browser_session_manager.js";
 import { type NodeInvokeRequest, type NodeInvokeResult } from "../tools/node_invoke.js";
 import { type TerminalSessionManager } from "../tools/terminal_session_manager.js";
 import type { AvailableToolName } from "./agentConfig.js";
@@ -27,6 +28,8 @@ export interface ToolOptions {
     };
     terminalOwnerId?: string;
     terminalSessionManager?: TerminalSessionManager;
+    browserSessionOwnerId?: string;
+    browserSessionManager?: BrowserSessionManager;
     searchConfig?: SearchConfig;
     mcpConfigs?: MCPServersConfig[];
     skillsDirectory?: string;

package/dist/agent/config/toolRegistry.js

@@ -1,6 +1,8 @@
 import { createLogger } from "../../logger.js";
 import { createBackgroundTerminalTool } from "../tools/background_terminal.js";
 import { createBrowserControlTool } from "../tools/browser_control.js";
+import { createBrowserSessionActionTool, createBrowserSessionCloseTool, createBrowserSessionListTool, createBrowserSessionStartTool } from "../tools/browser_session.js";
+import { getSharedBrowserSessionManager } from "../tools/browser_session_manager.js";
 import { createCodeSearchTool } from "../tools/code_search.js";
 import { createCommandExecuteTool } from "../tools/command_execute.js";
 import { createGitStatusTool } from "../tools/git_status.js";
@@ -22,7 +24,7 @@ const NODE_TOOL_NAMES = [
     "node_run"
 ];
 function createTool(name, options = {}) {
-    const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, terminalOwnerId = "default", terminalSessionManager = getSharedTerminalSessionManager(), searchConfig = {
+    const { workspace = process.cwd(), executionWorkspace, blockedCommands, allowScriptExecution = true, timeout = 300000, terminalOwnerId = "default", terminalSessionManager = getSharedTerminalSessionManager(), browserSessionOwnerId = "default", browserSessionManager = getSharedBrowserSessionManager(), searchConfig = {
         provider: "duckduckgo",
         maxResults: 5
     }, skillsDirectory = "skills", dynamicUiEnabled = true } = options;
@@ -67,6 +69,74 @@ function createTool(name, options = {}) {
                 allowScriptExecution,
                 commandTimeout: timeout
             });
+        case "browser_session_start":
+            return createBrowserSessionStartTool({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
+        case "browser_session_action":
+            return createBrowserSessionActionTool({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
+        case "browser_session_close":
+            return createBrowserSessionCloseTool({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
+        case "browser_session_list":
+            return createBrowserSessionListTool({
+                workspace: runtimeWorkspace,
+                configWorkspace: workspace,
+                launchTimeoutMs: timeout,
+                browserProfile: options.browserProfile,
+                browserTransport: options.browserTransport,
+                profilesRootDir: options.browserProfilesDirectory,
+                profilePaths: options.browserProfiles,
+                browserExtensions: options.browserExtensions,
+                extensionsRootDir: options.browserExtensionsDirectory,
+                extensionPaths: options.browserExtensionsById,
+                defaultExtensions: options.browserDefaultExtensions,
+                relayConfig: options.browserRelay,
+                ownerId: browserSessionOwnerId,
+                sessionManager: browserSessionManager
+            });
         case "node_notify":
             return createNodeNotifyTool({
                 nodeInvoker: options.nodeInvoker,
@@ -122,6 +192,10 @@ function getAvailableTools() {
         "internet_search",
         "web_crawler",
         "browser_control",
+        "browser_session_start",
+        "browser_session_action",
+        "browser_session_close",
+        "browser_session_list",
         "command_execute",
         "background_terminal",
         ...NODE_TOOL_NAMES,

package/dist/agent/middleware/large-tool-results.cjs

@@ -0,0 +1,207 @@
+"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__, {
+    createLargeToolResultsMiddleware: ()=>createLargeToolResultsMiddleware
+});
+const messages_namespaceObject = require("@langchain/core/messages");
+const langgraph_namespaceObject = require("@langchain/langgraph");
+const external_langchain_namespaceObject = require("langchain");
+const DEFAULT_TOOL_TOKEN_LIMIT_BEFORE_EVICT = 20000;
+const NUM_CHARS_PER_TOKEN = 4;
+const MAX_PREVIEW_LINE_CHARS = 1000;
+const PREVIEW_HEAD_LINES = 5;
+const PREVIEW_TAIL_LINES = 5;
+const LARGE_TOOL_RESULTS_DIR = "/large_tool_results";
+const DEFAULT_EXCLUDED_TOOLS = new Set([
+    "ls",
+    "glob",
+    "grep",
+    "read_file",
+    "edit_file",
+    "write_file",
+    "execute"
+]);
+const sanitizeToolCallId = (toolCallId)=>toolCallId.replace(/\./g, "_").replace(/\//g, "_").replace(/\\/g, "_");
+const formatContentWithLineNumbers = (lines, startLine = 1)=>lines.map((line, index)=>`${String(startLine + index).padStart(4, " ")} | ${line}`).join("\n");
+const createContentPreview = (content, headLines = PREVIEW_HEAD_LINES, tailLines = PREVIEW_TAIL_LINES)=>{
+    const lines = content.split("\n");
+    if (lines.length <= headLines + tailLines) return formatContentWithLineNumbers(lines.map((line)=>line.slice(0, MAX_PREVIEW_LINE_CHARS)));
+    const head = lines.slice(0, headLines).map((line)=>line.slice(0, MAX_PREVIEW_LINE_CHARS));
+    const tail = lines.slice(-tailLines).map((line)=>line.slice(0, MAX_PREVIEW_LINE_CHARS));
+    return [
+        formatContentWithLineNumbers(head, 1),
+        `... [${lines.length - headLines - tailLines} lines truncated] ...`,
+        formatContentWithLineNumbers(tail, lines.length - tailLines + 1)
+    ].join("\n");
+};
+const serializeToolContent = (content)=>{
+    if ("string" == typeof content) return {
+        serialized: content,
+        extension: ".txt"
+    };
+    if (null == content || "number" == typeof content || "boolean" == typeof content || "bigint" == typeof content) return {
+        serialized: String(content),
+        extension: ".txt"
+    };
+    try {
+        return {
+            serialized: JSON.stringify(content, null, 2),
+            extension: ".json"
+        };
+    } catch  {
+        return null;
+    }
+};
+const buildEvictedMessage = (params)=>{
+    if (!params.filePath) return [
+        `Tool result too large. Wingman replaced the full output for tool call ${params.toolCallId} with a preview to keep the model context safe.`,
+        params.writeError ? `The full output could not be persisted to the agent filesystem: ${params.writeError}` : null,
+        "Preview:",
+        params.contentPreview
+    ].filter(Boolean).join("\n\n");
+    return [
+        `Tool result too large. The full output for tool call ${params.toolCallId} was saved to ${params.filePath}.`,
+        "Use read_file with pagination to inspect it safely, for example offset=0 and limit=100.",
+        "Preview:",
+        params.contentPreview
+    ].join("\n\n");
+};
+const createToolMessageReplacement = (message, content)=>new messages_namespaceObject.ToolMessage({
+        content,
+        tool_call_id: message.tool_call_id,
+        name: message.name,
+        id: message.id,
+        artifact: message.artifact,
+        status: message.status,
+        metadata: message.metadata,
+        additional_kwargs: message.additional_kwargs,
+        response_metadata: message.response_metadata
+    });
+const processToolMessage = async (message, request, backend, maxCharsBeforeEvict, excludedTools)=>{
+    const toolName = request.toolCall?.name || message.name;
+    if (toolName && excludedTools.has(toolName)) return {
+        message,
+        filesUpdate: null,
+        changed: false
+    };
+    const serialized = serializeToolContent(message.content);
+    if (!serialized || serialized.serialized.length <= maxCharsBeforeEvict) return {
+        message,
+        filesUpdate: null,
+        changed: false
+    };
+    const toolCallId = request.toolCall?.id || message.tool_call_id || `${toolName || "tool"}_${Date.now()}`;
+    const safeToolCallId = sanitizeToolCallId(toolCallId);
+    const targetPath = `${LARGE_TOOL_RESULTS_DIR}/${safeToolCallId}${serialized.extension}`;
+    const preview = createContentPreview(serialized.serialized);
+    try {
+        const writeResult = await backend.write(targetPath, serialized.serialized);
+        const replacement = createToolMessageReplacement(message, buildEvictedMessage({
+            toolCallId,
+            filePath: writeResult.error ? void 0 : writeResult.path || targetPath,
+            contentPreview: preview,
+            writeError: writeResult.error
+        }));
+        return {
+            message: replacement,
+            filesUpdate: writeResult.error ? null : writeResult.filesUpdate ?? null,
+            changed: true
+        };
+    } catch (error) {
+        return {
+            message: createToolMessageReplacement(message, buildEvictedMessage({
+                toolCallId,
+                contentPreview: preview,
+                writeError: error instanceof Error ? error.message : String(error)
+            })),
+            filesUpdate: null,
+            changed: true
+        };
+    }
+};
+const createLargeToolResultsMiddleware = (options)=>{
+    const maxCharsBeforeEvict = (options.toolTokenLimitBeforeEvict ?? DEFAULT_TOOL_TOKEN_LIMIT_BEFORE_EVICT) * NUM_CHARS_PER_TOKEN;
+    const excludedTools = new Set(options.excludedTools ?? DEFAULT_EXCLUDED_TOOLS);
+    return {
+        name: "large-tool-results-middleware",
+        [external_langchain_namespaceObject.MIDDLEWARE_BRAND]: true,
+        wrapToolCall: async (request, handler)=>{
+            const result = await handler(request);
+            if (maxCharsBeforeEvict <= 0) return result;
+            const backend = options.backend();
+            if (messages_namespaceObject.ToolMessage.isInstance(result)) {
+                const processed = await processToolMessage(result, request, backend, maxCharsBeforeEvict, excludedTools);
+                if (processed.filesUpdate) return new langgraph_namespaceObject.Command({
+                    update: {
+                        files: processed.filesUpdate,
+                        messages: [
+                            processed.message
+                        ]
+                    }
+                });
+                return processed.message;
+            }
+            if (!(0, langgraph_namespaceObject.isCommand)(result)) return result;
+            const update = result.update;
+            if (!update?.messages || !Array.isArray(update.messages)) return result;
+            let changed = false;
+            const processedMessages = [];
+            let mergedFiles = update.files ? {
+                ...update.files
+            } : void 0;
+            for (const message of update.messages){
+                if (!messages_namespaceObject.ToolMessage.isInstance(message)) {
+                    processedMessages.push(message);
+                    continue;
+                }
+                const processed = await processToolMessage(message, request, backend, maxCharsBeforeEvict, excludedTools);
+                processedMessages.push(processed.message);
+                if (processed.changed) changed = true;
+                if (processed.filesUpdate) mergedFiles = {
+                    ...mergedFiles ?? {},
+                    ...processed.filesUpdate
+                };
+            }
+            if (!changed) return result;
+            return new langgraph_namespaceObject.Command({
+                update: {
+                    ...update,
+                    messages: processedMessages,
+                    ...mergedFiles ? {
+                        files: mergedFiles
+                    } : {}
+                }
+            });
+        }
+    };
+};
+exports.createLargeToolResultsMiddleware = __webpack_exports__.createLargeToolResultsMiddleware;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLargeToolResultsMiddleware"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/middleware/large-tool-results.d.ts

@@ -0,0 +1,16 @@
+import { type AgentMiddleware } from "langchain";
+type ToolResultWriteResult = {
+    error?: string;
+    path?: string;
+    filesUpdate?: Record<string, unknown> | null;
+};
+type ToolResultBackend = {
+    write: (filePath: string, content: string) => Promise<ToolResultWriteResult> | ToolResultWriteResult;
+};
+type LargeToolResultsMiddlewareOptions = {
+    backend: () => ToolResultBackend;
+    toolTokenLimitBeforeEvict?: number;
+    excludedTools?: Iterable<string>;
+};
+export declare const createLargeToolResultsMiddleware: (options: LargeToolResultsMiddlewareOptions) => AgentMiddleware;
+export {};