@wingman-ai/gateway 0.5.4 → 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/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");

package/dist/agent/tools/browser_control.cjs

@@ -46,7 +46,7 @@ const createBrowserControlTool = (options = {}, dependencies = {})=>(0, external
         }
     }, {
         name: "browser_control",
-        description: 'Native browser automation for Wingman using Chrome/Chromium runtime control. Transport is selected by config or the optional input override ("auto", "playwright", or "relay"): Playwright persistent-context is preferred for persistent profiles, CDP is used for standard runs with persistent-context fallback, and relay can bridge a live extension-attached tab. This is a first-class runtime capability, not an MCP server. Use it for JavaScript-rendered pages, interactions, screenshots, and structured extraction.',
+        description: 'Use this only when the user explicitly wants you to use or take over their existing browser, live tab, or extension-attached session (for example: "use my browser" or "take control of my browser"). Transport is selected by config or the optional input override ("auto", "playwright", or "relay"): Playwright persistent-context is preferred for persistent profiles, CDP is used for standard runs with persistent-context fallback, and relay can bridge a live extension-attached tab. For normal browser automation, screenshots, and QA, prefer browser_session_start/browser_session_action/browser_session_close.',
         schema: external_browser_runtime_cjs_namespaceObject.BrowserControlInputSchema
     });
 exports.clearStaleDevtoolsArtifacts = __webpack_exports__.clearStaleDevtoolsArtifacts;

package/dist/agent/tools/browser_control.js

@@ -17,7 +17,7 @@ const createBrowserControlTool = (options = {}, dependencies = {})=>tool(async (
         }
     }, {
         name: "browser_control",
-        description: 'Native browser automation for Wingman using Chrome/Chromium runtime control. Transport is selected by config or the optional input override ("auto", "playwright", or "relay"): Playwright persistent-context is preferred for persistent profiles, CDP is used for standard runs with persistent-context fallback, and relay can bridge a live extension-attached tab. This is a first-class runtime capability, not an MCP server. Use it for JavaScript-rendered pages, interactions, screenshots, and structured extraction.',
+        description: 'Use this only when the user explicitly wants you to use or take over their existing browser, live tab, or extension-attached session (for example: "use my browser" or "take control of my browser"). Transport is selected by config or the optional input override ("auto", "playwright", or "relay"): Playwright persistent-context is preferred for persistent profiles, CDP is used for standard runs with persistent-context fallback, and relay can bridge a live extension-attached tab. For normal browser automation, screenshots, and QA, prefer browser_session_start/browser_session_action/browser_session_close.',
         schema: BrowserControlInputSchema
     });
 export { clearStaleDevtoolsArtifacts, createBrowserControlTool };