@wingman-ai/gateway 0.5.3 → 0.6.0

package/dist/agent/backend/filtered-backend.cjs

@@ -0,0 +1,130 @@
+"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__, {
+    BLOCKED_BACKEND_PATH_MESSAGE: ()=>BLOCKED_BACKEND_PATH_MESSAGE,
+    DEFAULT_HIDDEN_BACKEND_SEGMENTS: ()=>DEFAULT_HIDDEN_BACKEND_SEGMENTS,
+    createFilteredBackend: ()=>createFilteredBackend,
+    pathUsesHiddenSegment: ()=>pathUsesHiddenSegment
+});
+const external_node_path_namespaceObject = require("node:path");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_HIDDEN_BACKEND_SEGMENTS = [
+    "conversation_history"
+];
+const BLOCKED_BACKEND_PATH_MESSAGE = "Access to conversation history archives is unavailable to agent file tools. Use the current thread context or /memories/ instead.";
+const normalizeSegment = (value)=>value.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").toLowerCase();
+const normalizeVirtualPath = (value)=>{
+    const normalized = value.replace(/\\/g, "/").trim();
+    if (!normalized) return "/";
+    if (normalized.startsWith("/")) return external_node_path_namespaceObject.posix.normalize(normalized);
+    return external_node_path_namespaceObject.posix.normalize(`/${normalized.replace(/^\.?\//, "")}`);
+};
+const resolveHiddenSegments = (segments)=>{
+    const normalized = [
+        ...segments
+    ].map(normalizeSegment).filter((segment)=>segment.length > 0);
+    return new Set(normalized);
+};
+const getPathSegments = (value)=>normalizeVirtualPath(value).split("/").map((segment)=>segment.trim().toLowerCase()).filter(Boolean);
+const pathUsesHiddenSegment = (value, hiddenPathSegments = DEFAULT_HIDDEN_BACKEND_SEGMENTS)=>{
+    const hiddenSegments = resolveHiddenSegments(hiddenPathSegments);
+    if (0 === hiddenSegments.size) return false;
+    return getPathSegments(value).some((segment)=>hiddenSegments.has(segment));
+};
+const filterPathEntries = (entries, hiddenSegments)=>entries.filter((entry)=>!getPathSegments(entry.path).some((segment)=>hiddenSegments.has(segment)));
+const createBlockedResult = (path, message)=>({
+        error: message,
+        path,
+        filesUpdate: null
+    });
+class FilteredBackend {
+    isHiddenPath(value) {
+        return this.hiddenSegments.size > 0 && getPathSegments(value).some((segment)=>this.hiddenSegments.has(segment));
+    }
+    async lsInfo(path) {
+        if (this.isHiddenPath(path)) return [];
+        const entries = await this.delegate.lsInfo(path);
+        return filterPathEntries(entries, this.hiddenSegments);
+    }
+    async read(filePath, offset, limit) {
+        if (this.isHiddenPath(filePath)) return this.blockedPathMessage;
+        return await this.delegate.read(filePath, offset, limit);
+    }
+    async readRaw(filePath) {
+        if (this.isHiddenPath(filePath)) throw new Error(this.blockedPathMessage);
+        return await this.delegate.readRaw(filePath);
+    }
+    async grepRaw(pattern, path, glob) {
+        if ("string" == typeof path && this.isHiddenPath(path)) return [];
+        const result = await this.delegate.grepRaw(pattern, path, glob);
+        if ("string" == typeof result) return result;
+        return filterPathEntries(result, this.hiddenSegments);
+    }
+    async globInfo(pattern, path = "/") {
+        if (this.isHiddenPath(path)) return [];
+        const entries = await this.delegate.globInfo(pattern, path);
+        return filterPathEntries(entries, this.hiddenSegments);
+    }
+    async write(filePath, content) {
+        if (this.isHiddenPath(filePath)) return createBlockedResult(filePath, this.blockedPathMessage);
+        return await this.delegate.write(filePath, content);
+    }
+    async edit(filePath, oldString, newString, replaceAll) {
+        if (this.isHiddenPath(filePath)) return createBlockedResult(filePath, this.blockedPathMessage);
+        return await this.delegate.edit(filePath, oldString, newString, replaceAll);
+    }
+    constructor(delegate, options = {}){
+        _define_property(this, "delegate", void 0);
+        _define_property(this, "hiddenSegments", void 0);
+        _define_property(this, "blockedPathMessage", void 0);
+        this.delegate = delegate;
+        this.hiddenSegments = resolveHiddenSegments(options.hiddenPathSegments ?? DEFAULT_HIDDEN_BACKEND_SEGMENTS);
+        this.blockedPathMessage = options.blockedPathMessage ?? BLOCKED_BACKEND_PATH_MESSAGE;
+    }
+}
+const createFilteredBackend = (delegate, options = {})=>new FilteredBackend(delegate, options);
+exports.BLOCKED_BACKEND_PATH_MESSAGE = __webpack_exports__.BLOCKED_BACKEND_PATH_MESSAGE;
+exports.DEFAULT_HIDDEN_BACKEND_SEGMENTS = __webpack_exports__.DEFAULT_HIDDEN_BACKEND_SEGMENTS;
+exports.createFilteredBackend = __webpack_exports__.createFilteredBackend;
+exports.pathUsesHiddenSegment = __webpack_exports__.pathUsesHiddenSegment;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BLOCKED_BACKEND_PATH_MESSAGE",
+    "DEFAULT_HIDDEN_BACKEND_SEGMENTS",
+    "createFilteredBackend",
+    "pathUsesHiddenSegment"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/backend/filtered-backend.d.ts

@@ -0,0 +1,10 @@
+import type { BackendProtocol } from "deepagents";
+export declare const DEFAULT_HIDDEN_BACKEND_SEGMENTS: readonly ["conversation_history"];
+export declare const BLOCKED_BACKEND_PATH_MESSAGE = "Access to conversation history archives is unavailable to agent file tools. Use the current thread context or /memories/ instead.";
+type FilteredBackendOptions = {
+    hiddenPathSegments?: Iterable<string>;
+    blockedPathMessage?: string;
+};
+export declare const pathUsesHiddenSegment: (value: string, hiddenPathSegments?: Iterable<string>) => boolean;
+export declare const createFilteredBackend: (delegate: BackendProtocol, options?: FilteredBackendOptions) => BackendProtocol;
+export {};

package/dist/agent/backend/filtered-backend.js

@@ -0,0 +1,87 @@
+import { posix } from "node:path";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_HIDDEN_BACKEND_SEGMENTS = [
+    "conversation_history"
+];
+const BLOCKED_BACKEND_PATH_MESSAGE = "Access to conversation history archives is unavailable to agent file tools. Use the current thread context or /memories/ instead.";
+const normalizeSegment = (value)=>value.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").toLowerCase();
+const normalizeVirtualPath = (value)=>{
+    const normalized = value.replace(/\\/g, "/").trim();
+    if (!normalized) return "/";
+    if (normalized.startsWith("/")) return posix.normalize(normalized);
+    return posix.normalize(`/${normalized.replace(/^\.?\//, "")}`);
+};
+const resolveHiddenSegments = (segments)=>{
+    const normalized = [
+        ...segments
+    ].map(normalizeSegment).filter((segment)=>segment.length > 0);
+    return new Set(normalized);
+};
+const getPathSegments = (value)=>normalizeVirtualPath(value).split("/").map((segment)=>segment.trim().toLowerCase()).filter(Boolean);
+const pathUsesHiddenSegment = (value, hiddenPathSegments = DEFAULT_HIDDEN_BACKEND_SEGMENTS)=>{
+    const hiddenSegments = resolveHiddenSegments(hiddenPathSegments);
+    if (0 === hiddenSegments.size) return false;
+    return getPathSegments(value).some((segment)=>hiddenSegments.has(segment));
+};
+const filterPathEntries = (entries, hiddenSegments)=>entries.filter((entry)=>!getPathSegments(entry.path).some((segment)=>hiddenSegments.has(segment)));
+const createBlockedResult = (path, message)=>({
+        error: message,
+        path,
+        filesUpdate: null
+    });
+class FilteredBackend {
+    isHiddenPath(value) {
+        return this.hiddenSegments.size > 0 && getPathSegments(value).some((segment)=>this.hiddenSegments.has(segment));
+    }
+    async lsInfo(path) {
+        if (this.isHiddenPath(path)) return [];
+        const entries = await this.delegate.lsInfo(path);
+        return filterPathEntries(entries, this.hiddenSegments);
+    }
+    async read(filePath, offset, limit) {
+        if (this.isHiddenPath(filePath)) return this.blockedPathMessage;
+        return await this.delegate.read(filePath, offset, limit);
+    }
+    async readRaw(filePath) {
+        if (this.isHiddenPath(filePath)) throw new Error(this.blockedPathMessage);
+        return await this.delegate.readRaw(filePath);
+    }
+    async grepRaw(pattern, path, glob) {
+        if ("string" == typeof path && this.isHiddenPath(path)) return [];
+        const result = await this.delegate.grepRaw(pattern, path, glob);
+        if ("string" == typeof result) return result;
+        return filterPathEntries(result, this.hiddenSegments);
+    }
+    async globInfo(pattern, path = "/") {
+        if (this.isHiddenPath(path)) return [];
+        const entries = await this.delegate.globInfo(pattern, path);
+        return filterPathEntries(entries, this.hiddenSegments);
+    }
+    async write(filePath, content) {
+        if (this.isHiddenPath(filePath)) return createBlockedResult(filePath, this.blockedPathMessage);
+        return await this.delegate.write(filePath, content);
+    }
+    async edit(filePath, oldString, newString, replaceAll) {
+        if (this.isHiddenPath(filePath)) return createBlockedResult(filePath, this.blockedPathMessage);
+        return await this.delegate.edit(filePath, oldString, newString, replaceAll);
+    }
+    constructor(delegate, options = {}){
+        _define_property(this, "delegate", void 0);
+        _define_property(this, "hiddenSegments", void 0);
+        _define_property(this, "blockedPathMessage", void 0);
+        this.delegate = delegate;
+        this.hiddenSegments = resolveHiddenSegments(options.hiddenPathSegments ?? DEFAULT_HIDDEN_BACKEND_SEGMENTS);
+        this.blockedPathMessage = options.blockedPathMessage ?? BLOCKED_BACKEND_PATH_MESSAGE;
+    }
+}
+const createFilteredBackend = (delegate, options = {})=>new FilteredBackend(delegate, options);
+export { BLOCKED_BACKEND_PATH_MESSAGE, DEFAULT_HIDDEN_BACKEND_SEGMENTS, createFilteredBackend, pathUsesHiddenSegment };

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/additional-messages.cjs

@@ -27,6 +27,7 @@ __webpack_require__.d(__webpack_exports__, {
     additionalMessageMiddleware: ()=>additionalMessageMiddleware
 });
 const external_node_path_namespaceObject = require("node:path");
+const messages_namespaceObject = require("@langchain/core/messages");
 const external_langchain_namespaceObject = require("langchain");
 const external_utils_cjs_namespaceObject = require("../utils.cjs");
 const external_uiRegistry_cjs_namespaceObject = require("../uiRegistry.cjs");
@@ -57,6 +58,7 @@ const buildWorkingDirectoryMessage = (context)=>{
     if (!context.workspaceRoot) return null;
     return "** Working Directory **\n- Treat `./` as the current working directory for file and tool operations in this session.\n- Use relative paths such as `./test.md`; do not prepend the working directory absolute path.";
 };
+const buildSessionArtifactsMessage = ()=>"** Session Artifacts **\n- Treat /conversation_history as an internal summarization archive, not working context.\n- Do not inspect conversation history files through file tools or shell commands during normal task work.\n- Prefer the current thread state and /memories/ for durable context.";
 const resolveConnectedNodeIds = async (context)=>{
     if (context.nodeConnectedTargetsProvider) try {
         const rawTargets = await context.nodeConnectedTargetsProvider();
@@ -167,6 +169,7 @@ const additionalMessageMiddleware = (context = {})=>({
             if (outputLocation) lines.push(outputLocation);
             const workingDirectory = buildWorkingDirectoryMessage(context);
             if (workingDirectory) lines.push(workingDirectory);
+            lines.push(buildSessionArtifactsMessage());
             const nodeTargets = await buildNodeTargetsMessage(context);
             if (nodeTargets) lines.push(nodeTargets);
             lines.push("** Long-term memory **\n- Use /memories/ for durable notes across threads.\n- Store stable preferences, project context, decisions, and research notes.\n- Avoid transient logs; keep entries concise and organized.\n- Suggested paths: /memories/preferences.md, /memories/projects/<name>/context.md, /memories/projects/<name>/decisions.md");
@@ -184,7 +187,7 @@ const additionalMessageMiddleware = (context = {})=>({
             return {
                 ...input,
                 messages: [
-                    new external_langchain_namespaceObject.HumanMessage({
+                    new messages_namespaceObject.HumanMessage({
                         content: lines.join("\n\n"),
                         additional_kwargs: {
                             ui_hidden: true,

package/dist/agent/middleware/additional-messages.js

@@ -1,5 +1,6 @@
 import { isAbsolute, relative } from "node:path";
-import { HumanMessage, MIDDLEWARE_BRAND } from "langchain";
+import { HumanMessage } from "@langchain/core/messages";
+import { MIDDLEWARE_BRAND } from "langchain";
 import { getConfidentialityNotice } from "../utils.js";
 import { loadUiRegistry, resolveUiRegistryPath, summarizeUiRegistry } from "../uiRegistry.js";
 const INJECTION_SOURCE = "additional-message-middleware";
@@ -29,6 +30,7 @@ const buildWorkingDirectoryMessage = (context)=>{
     if (!context.workspaceRoot) return null;
     return "** Working Directory **\n- Treat `./` as the current working directory for file and tool operations in this session.\n- Use relative paths such as `./test.md`; do not prepend the working directory absolute path.";
 };
+const buildSessionArtifactsMessage = ()=>"** Session Artifacts **\n- Treat /conversation_history as an internal summarization archive, not working context.\n- Do not inspect conversation history files through file tools or shell commands during normal task work.\n- Prefer the current thread state and /memories/ for durable context.";
 const resolveConnectedNodeIds = async (context)=>{
     if (context.nodeConnectedTargetsProvider) try {
         const rawTargets = await context.nodeConnectedTargetsProvider();
@@ -139,6 +141,7 @@ const additionalMessageMiddleware = (context = {})=>({
             if (outputLocation) lines.push(outputLocation);
             const workingDirectory = buildWorkingDirectoryMessage(context);
             if (workingDirectory) lines.push(workingDirectory);
+            lines.push(buildSessionArtifactsMessage());
             const nodeTargets = await buildNodeTargetsMessage(context);
             if (nodeTargets) lines.push(nodeTargets);
             lines.push("** Long-term memory **\n- Use /memories/ for durable notes across threads.\n- Store stable preferences, project context, decisions, and research notes.\n- Avoid transient logs; keep entries concise and organized.\n- Suggested paths: /memories/preferences.md, /memories/projects/<name>/context.md, /memories/projects/<name>/decisions.md");