@wingman-ai/gateway 0.5.2 → 0.5.4

package/dist/agent/tools/browser_session.cjs

@@ -0,0 +1,153 @@
+"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__, {
+    createBrowserSessionActionTool: ()=>createBrowserSessionActionTool,
+    createBrowserSessionCloseTool: ()=>createBrowserSessionCloseTool,
+    createBrowserSessionListTool: ()=>createBrowserSessionListTool,
+    createBrowserSessionStartTool: ()=>createBrowserSessionStartTool
+});
+const external_langchain_namespaceObject = require("langchain");
+const external_zod_namespaceObject = require("zod");
+const external_browser_runtime_cjs_namespaceObject = require("./browser_runtime.cjs");
+const CloseBrowserSessionInputSchema = external_zod_namespaceObject.object({
+    session_id: external_zod_namespaceObject.string().min(1).describe("Existing browser session id to close")
+});
+const BrowserSessionListInputSchema = external_zod_namespaceObject.object({});
+const buildResponse = (payload)=>payload;
+const summarizeResult = (snapshot, summary)=>({
+        session_id: snapshot.sessionId,
+        status: snapshot.status,
+        transport_requested: snapshot.transportRequested,
+        transport_used: snapshot.transportUsed,
+        mode: snapshot.mode,
+        persistent_profile: snapshot.persistentProfile,
+        profile_id: snapshot.profileId || null,
+        profile_path: snapshot.profilePath || null,
+        reused_existing_session: snapshot.reusedExistingSession,
+        started_at: snapshot.startedAt,
+        updated_at: snapshot.updatedAt,
+        workspace: snapshot.workspace,
+        config_workspace: snapshot.configWorkspace,
+        final_url: summary?.finalUrl || snapshot.finalUrl || null,
+        title: summary?.title || snapshot.title || null,
+        fallback_reason: summary?.fallbackReason || null,
+        extensions: summary?.extensions || [],
+        action_results: summary?.actionResults || [],
+        browser: summary?.browser || null,
+        transport: summary?.transport || snapshot.transportUsed
+    });
+const createBrowserSessionStartTool = (options, dependencies = {})=>(0, external_langchain_namespaceObject.tool)(async (input)=>{
+        try {
+            const { snapshot, summary } = await options.sessionManager.startSession({
+                ownerId: options.ownerId,
+                options,
+                dependencies,
+                input
+            });
+            return buildResponse({
+                ok: true,
+                ...summarizeResult(snapshot, summary)
+            });
+        } catch (error) {
+            return buildResponse({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }, {
+        name: "browser_session_start",
+        description: 'Start a managed browser session that persists across multiple tool calls. Use this for iterative QA/debugging where the same browser state should survive across turns. Transport can be selected per session with "auto", "playwright", or "relay".',
+        schema: external_browser_runtime_cjs_namespaceObject.BrowserControlInputSchema
+    });
+const createBrowserSessionActionTool = (options)=>(0, external_langchain_namespaceObject.tool)(async (input)=>{
+        try {
+            const { session_id, ...actionInput } = input;
+            const { snapshot, summary } = await options.sessionManager.runSession({
+                ownerId: options.ownerId,
+                sessionId: session_id,
+                input: actionInput
+            });
+            return buildResponse({
+                ok: true,
+                ...summarizeResult(snapshot, summary)
+            });
+        } catch (error) {
+            return buildResponse({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }, {
+        name: "browser_session_action",
+        description: "Run browser actions inside an existing managed browser session. Use the session_id returned by browser_session_start to continue the same tab/profile state across multiple calls.",
+        schema: external_browser_runtime_cjs_namespaceObject.BrowserSessionActionInputSchema
+    });
+const createBrowserSessionCloseTool = (options)=>(0, external_langchain_namespaceObject.tool)(async ({ session_id })=>{
+        try {
+            const snapshot = await options.sessionManager.closeSession({
+                ownerId: options.ownerId,
+                sessionId: session_id
+            });
+            return buildResponse({
+                ok: true,
+                closed: true,
+                ...summarizeResult(snapshot, null)
+            });
+        } catch (error) {
+            return buildResponse({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }, {
+        name: "browser_session_close",
+        description: "Close a managed browser session and release any temporary browser resources or profile locks owned by that session.",
+        schema: CloseBrowserSessionInputSchema
+    });
+const createBrowserSessionListTool = (options)=>(0, external_langchain_namespaceObject.tool)(async ()=>{
+        const sessions = options.sessionManager.listSessions(options.ownerId);
+        return buildResponse({
+            ok: true,
+            sessions: sessions.map((snapshot)=>summarizeResult(snapshot, null))
+        });
+    }, {
+        name: "browser_session_list",
+        description: "List the managed browser sessions currently owned by this agent run. Use this to recover a session_id before continuing or closing a session.",
+        schema: BrowserSessionListInputSchema
+    });
+exports.createBrowserSessionActionTool = __webpack_exports__.createBrowserSessionActionTool;
+exports.createBrowserSessionCloseTool = __webpack_exports__.createBrowserSessionCloseTool;
+exports.createBrowserSessionListTool = __webpack_exports__.createBrowserSessionListTool;
+exports.createBrowserSessionStartTool = __webpack_exports__.createBrowserSessionStartTool;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBrowserSessionActionTool",
+    "createBrowserSessionCloseTool",
+    "createBrowserSessionListTool",
+    "createBrowserSessionStartTool"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});