@wingman-ai/gateway 0.1.5 → 0.2.0

package/dist/gateway/server.js

@@ -33,6 +33,21 @@ function _define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
+const API_CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization, X-Wingman-Token, X-Wingman-Password",
+    "Access-Control-Max-Age": "600"
+};
+function withApiCors(response) {
+    const headers = new Headers(response.headers);
+    for (const [key, value] of Object.entries(API_CORS_HEADERS))headers.set(key, value);
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers
+    });
+}
 class GatewayServer {
     async start() {
         if (void 0 === globalThis.Bun) throw new Error("Gateway server requires Bun runtime. Start with `bun ./bin/wingman gateway start`.");
@@ -350,7 +365,10 @@ class GatewayServer {
         this.broadcastSessionEvent(sessionKey, sessionMessage, ws);
         this.broadcastToClients(sessionMessage, {
             exclude: ws,
-            clientType: "webui",
+            clientTypes: [
+                "webui",
+                "desktop"
+            ],
             skipSessionId: sessionKey
         });
         const outputManager = new OutputManager("interactive");
@@ -590,14 +608,18 @@ class GatewayServer {
     }
     broadcastToClients(message, options) {
         let sent = 0;
-        for (const ws of this.connectedClients)if (!options?.exclude || ws !== options.exclude) {
-            if (!options?.clientType || ws.data.clientType === options.clientType) {
-                if (options?.skipSessionId) {
-                    const subscribers = this.sessionSubscriptions.get(options.skipSessionId);
-                    if (subscribers?.has(ws)) continue;
+        for (const ws of this.connectedClients){
+            if (!options?.exclude || ws !== options.exclude) {
+                if (!options?.clientType || ws.data.clientType === options.clientType) {
+                    if (!options?.clientTypes || !(options.clientTypes.length > 0) || options.clientTypes.includes(ws.data.clientType || "")) {
+                        if (options?.skipSessionId) {
+                            const subscribers = this.sessionSubscriptions.get(options.skipSessionId);
+                            if (subscribers?.has(ws)) continue;
+                        }
+                        this.sendMessage(ws, message);
+                        sent++;
+                    }
                 }
-                this.sendMessage(ws, message);
-                sent++;
             }
         }
         return sent;
@@ -846,6 +868,9 @@ class GatewayServer {
         const webhookResponse = await handleWebhookInvoke(ctx, this.webhookStore, req, url);
         if (webhookResponse) return webhookResponse;
         if (url.pathname.startsWith("/api/")) {
+            if ("OPTIONS" === req.method) return withApiCors(new Response(null, {
+                status: 204
+            }));
             if ("/api/config" === url.pathname) {
                 const agents = this.wingmanConfig.agents?.list?.map((agent)=>({
                         id: agent.id,
@@ -853,7 +878,7 @@ class GatewayServer {
                         default: agent.default
                     })) || [];
                 const defaultAgentId = this.router.selectAgent();
-                return new Response(JSON.stringify({
+                return withApiCors(new Response(JSON.stringify({
                     gatewayHost: this.config.host,
                     gatewayPort: this.config.port,
                     requireAuth: this.auth.isAuthRequired(),
@@ -866,15 +891,15 @@ class GatewayServer {
                     headers: {
                         "Content-Type": "application/json"
                     }
-                });
+                }));
             }
             const apiResponse = await handleWebhooksApi(ctx, this.webhookStore, req, url) || await handleRoutinesApi(ctx, this.routineStore, req, url) || await handleAgentsApi(ctx, req, url) || await handleProvidersApi(ctx, req, url) || await handleVoiceApi(ctx, req, url) || await handleFsApi(ctx, req, url) || await handleSessionsApi(ctx, req, url);
-            if (apiResponse) return apiResponse;
-            if ("/api/health" === url.pathname) return this.handleHealthCheck();
-            if ("/api/stats" === url.pathname) return this.handleStats();
-            return new Response("Not Found", {
+            if (apiResponse) return withApiCors(apiResponse);
+            if ("/api/health" === url.pathname) return withApiCors(this.handleHealthCheck());
+            if ("/api/stats" === url.pathname) return withApiCors(this.handleStats());
+            return withApiCors(new Response("Not Found", {
                 status: 404
-            });
+            }));
         }
         if ("GET" !== req.method) return new Response("Method Not Allowed", {
             status: 405
@@ -1127,11 +1152,20 @@ class GatewayServer {
 }
 function buildAttachmentPreview(attachments) {
     if (!attachments || 0 === attachments.length) return "Attachment";
+    let hasFile = false;
     let hasAudio = false;
     let hasImage = false;
-    for (const attachment of attachments)if (isAudioAttachment(attachment)) hasAudio = true;
-    else hasImage = true;
+    for (const attachment of attachments){
+        if (isFileAttachment(attachment)) {
+            hasFile = true;
+            continue;
+        }
+        if (isAudioAttachment(attachment)) hasAudio = true;
+        else hasImage = true;
+    }
     const count = attachments.length;
+    if (hasFile && (hasAudio || hasImage)) return count > 1 ? "File and media attachments" : "File and media attachment";
+    if (hasFile) return count > 1 ? "File attachments" : "File attachment";
     if (hasAudio && hasImage) return count > 1 ? "Media attachments" : "Media attachment";
     if (hasAudio) return count > 1 ? "Audio attachments" : "Audio attachment";
     return count > 1 ? "Image attachments" : "Image attachment";
@@ -1142,4 +1176,8 @@ function isAudioAttachment(attachment) {
     if (attachment.dataUrl?.startsWith("data:audio/")) return true;
     return false;
 }
+function isFileAttachment(attachment) {
+    if ("file" === attachment.kind) return true;
+    return "string" == typeof attachment.textContent;
+}
 export { GatewayServer };

package/dist/gateway/types.d.ts

@@ -45,7 +45,15 @@ export interface AudioAttachment {
     name?: string;
     size?: number;
 }
-export type MediaAttachment = ImageAttachment | AudioAttachment;
+export interface FileAttachment {
+    kind: "file";
+    dataUrl: string;
+    textContent: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+}
+export type MediaAttachment = ImageAttachment | AudioAttachment | FileAttachment;
 export interface AgentRequestPayload {
     agentId?: string;
     content?: string;

package/dist/tests/additionalMessageMiddleware.test.cjs

@@ -60,6 +60,9 @@ const additional_messages_cjs_namespaceObject = require("../agent/middleware/add
         const content = injected.content ?? "";
         (0, external_vitest_namespaceObject.expect)(content).toContain("Confidentiality");
         (0, external_vitest_namespaceObject.expect)(content).toContain("Do not disclose");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Working Directory");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("current working directory");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Use relative paths");
         (0, external_vitest_namespaceObject.expect)(content).not.toContain("Operating System:");
         (0, external_vitest_namespaceObject.expect)(content).not.toContain("Architecture:");
         (0, external_vitest_namespaceObject.expect)(content).not.toContain("Default Shell:");
@@ -68,6 +71,29 @@ const additional_messages_cjs_namespaceObject = require("../agent/middleware/add
         (0, external_vitest_namespaceObject.expect)(content).not.toContain(workdir);
         (0, external_vitest_namespaceObject.expect)(content).not.toContain(workspaceRoot);
     });
+    (0, external_vitest_namespaceObject.it)("uses virtual output path when workdir is outside the workspace root", async ()=>{
+        const workspaceRoot = external_node_path_default().resolve("repo");
+        const workdir = external_node_path_default().resolve("external-output");
+        const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)({
+            workspaceRoot,
+            workdir,
+            outputVirtualPath: "/workdir/"
+        });
+        const input = {
+            messages: [
+                new external_langchain_namespaceObject.HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const injected = result.messages[0];
+        const content = injected.content ?? "";
+        (0, external_vitest_namespaceObject.expect)(content).toContain("session output directory");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("/workdir/");
+        (0, external_vitest_namespaceObject.expect)(content).not.toContain("(path hidden)");
+        (0, external_vitest_namespaceObject.expect)(content).not.toContain(workdir);
+    });
     (0, external_vitest_namespaceObject.it)("does not inject the additional message twice", async ()=>{
         const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)();
         const input = {

package/dist/tests/additionalMessageMiddleware.test.js

@@ -36,6 +36,9 @@ describe("additionalMessageMiddleware", ()=>{
         const content = injected.content ?? "";
         expect(content).toContain("Confidentiality");
         expect(content).toContain("Do not disclose");
+        expect(content).toContain("Working Directory");
+        expect(content).toContain("current working directory");
+        expect(content).toContain("Use relative paths");
         expect(content).not.toContain("Operating System:");
         expect(content).not.toContain("Architecture:");
         expect(content).not.toContain("Default Shell:");
@@ -44,6 +47,29 @@ describe("additionalMessageMiddleware", ()=>{
         expect(content).not.toContain(workdir);
         expect(content).not.toContain(workspaceRoot);
     });
+    it("uses virtual output path when workdir is outside the workspace root", async ()=>{
+        const workspaceRoot = node_path.resolve("repo");
+        const workdir = node_path.resolve("external-output");
+        const middleware = additionalMessageMiddleware({
+            workspaceRoot,
+            workdir,
+            outputVirtualPath: "/workdir/"
+        });
+        const input = {
+            messages: [
+                new HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const injected = result.messages[0];
+        const content = injected.content ?? "";
+        expect(content).toContain("session output directory");
+        expect(content).toContain("/workdir/");
+        expect(content).not.toContain("(path hidden)");
+        expect(content).not.toContain(workdir);
+    });
     it("does not inject the additional message twice", async ()=>{
         const middleware = additionalMessageMiddleware();
         const input = {

package/dist/tests/agentInvokerAttachments.test.cjs

@@ -60,6 +60,129 @@ const agentInvoker_cjs_namespaceObject = require("../cli/core/agentInvoker.cjs")
             }
         ]);
     });
+    (0, external_vitest_namespaceObject.it)("builds text parts for extracted file attachments", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("Review this", [
+            {
+                kind: "file",
+                dataUrl: "",
+                name: "notes.md",
+                mimeType: "text/markdown",
+                textContent: "# Notes\n- keep media uploads working"
+            }
+        ]);
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "text",
+                text: "Review this"
+            },
+            {
+                type: "text",
+                text: "[Attached file: notes.md (text/markdown)]\n# Notes\n- keep media uploads working"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("falls back when file attachment has no extracted text", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("", [
+            {
+                kind: "file",
+                dataUrl: "",
+                name: "scan.pdf",
+                mimeType: "application/pdf",
+                textContent: "   "
+            }
+        ]);
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "text",
+                text: "[Attached file: scan.pdf (application/pdf)]\n[No extractable text content provided.]"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("uses responses input_file blocks for pdfs when responses api is enabled", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("Summarize this", [
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "report.pdf",
+                mimeType: "application/pdf",
+                textContent: "fallback text"
+            }
+        ], {
+            profile: {
+                pdfInputs: true
+            },
+            useResponsesApi: true
+        });
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "text",
+                text: "Summarize this"
+            },
+            {
+                type: "input_file",
+                file_data: "data:application/pdf;base64,JVBERi0xLjQK",
+                filename: "report.pdf"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("uses legacy file blocks for pdfs when responses api is not enabled", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("Summarize this", [
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "report.pdf",
+                mimeType: "application/pdf",
+                textContent: "fallback text"
+            }
+        ], {
+            profile: {
+                pdfInputs: true
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "text",
+                text: "Summarize this"
+            },
+            {
+                type: "file",
+                source_type: "base64",
+                mime_type: "application/pdf",
+                data: "JVBERi0xLjQK",
+                metadata: {
+                    filename: "report.pdf",
+                    name: "report.pdf",
+                    title: "report.pdf"
+                }
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("falls back to extracted text when native pdf data is missing", ()=>{
+        const result = (0, agentInvoker_cjs_namespaceObject.buildUserContent)("", [
+            {
+                kind: "file",
+                dataUrl: "",
+                name: "report.pdf",
+                mimeType: "application/pdf",
+                textContent: "Parsed fallback content."
+            }
+        ], {
+            profile: {
+                pdfInputs: true
+            }
+        });
+        (0, external_vitest_namespaceObject.expect)(Array.isArray(result)).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                type: "text",
+                text: "[Attached file: report.pdf (application/pdf)]\nParsed fallback content."
+            }
+        ]);
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/agentInvokerAttachments.test.js

@@ -58,4 +58,127 @@ describe("buildUserContent", ()=>{
             }
         ]);
     });
+    it("builds text parts for extracted file attachments", ()=>{
+        const result = buildUserContent("Review this", [
+            {
+                kind: "file",
+                dataUrl: "",
+                name: "notes.md",
+                mimeType: "text/markdown",
+                textContent: "# Notes\n- keep media uploads working"
+            }
+        ]);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "Review this"
+            },
+            {
+                type: "text",
+                text: "[Attached file: notes.md (text/markdown)]\n# Notes\n- keep media uploads working"
+            }
+        ]);
+    });
+    it("falls back when file attachment has no extracted text", ()=>{
+        const result = buildUserContent("", [
+            {
+                kind: "file",
+                dataUrl: "",
+                name: "scan.pdf",
+                mimeType: "application/pdf",
+                textContent: "   "
+            }
+        ]);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "[Attached file: scan.pdf (application/pdf)]\n[No extractable text content provided.]"
+            }
+        ]);
+    });
+    it("uses responses input_file blocks for pdfs when responses api is enabled", ()=>{
+        const result = buildUserContent("Summarize this", [
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "report.pdf",
+                mimeType: "application/pdf",
+                textContent: "fallback text"
+            }
+        ], {
+            profile: {
+                pdfInputs: true
+            },
+            useResponsesApi: true
+        });
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "Summarize this"
+            },
+            {
+                type: "input_file",
+                file_data: "data:application/pdf;base64,JVBERi0xLjQK",
+                filename: "report.pdf"
+            }
+        ]);
+    });
+    it("uses legacy file blocks for pdfs when responses api is not enabled", ()=>{
+        const result = buildUserContent("Summarize this", [
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "report.pdf",
+                mimeType: "application/pdf",
+                textContent: "fallback text"
+            }
+        ], {
+            profile: {
+                pdfInputs: true
+            }
+        });
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "Summarize this"
+            },
+            {
+                type: "file",
+                source_type: "base64",
+                mime_type: "application/pdf",
+                data: "JVBERi0xLjQK",
+                metadata: {
+                    filename: "report.pdf",
+                    name: "report.pdf",
+                    title: "report.pdf"
+                }
+            }
+        ]);
+    });
+    it("falls back to extracted text when native pdf data is missing", ()=>{
+        const result = buildUserContent("", [
+            {
+                kind: "file",
+                dataUrl: "",
+                name: "report.pdf",
+                mimeType: "application/pdf",
+                textContent: "Parsed fallback content."
+            }
+        ], {
+            profile: {
+                pdfInputs: true
+            }
+        });
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toEqual([
+            {
+                type: "text",
+                text: "[Attached file: report.pdf (application/pdf)]\nParsed fallback content."
+            }
+        ]);
+    });
 });

package/dist/tests/agentInvokerWorkdir.test.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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);
+})();
+var __webpack_exports__ = {};
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_vitest_namespaceObject = require("vitest");
+const agentInvoker_cjs_namespaceObject = require("../cli/core/agentInvoker.cjs");
+(0, external_vitest_namespaceObject.describe)("resolveExternalOutputMount", ()=>{
+    const workspace = external_node_path_default().resolve("workspace");
+    (0, external_vitest_namespaceObject.it)("mounts external workdir paths", ()=>{
+        const workdir = external_node_path_default().resolve("outside", "session-output");
+        const mount = (0, agentInvoker_cjs_namespaceObject.resolveExternalOutputMount)(workspace, workdir, null);
+        (0, external_vitest_namespaceObject.expect)(mount).toEqual({
+            virtualPath: agentInvoker_cjs_namespaceObject.WORKDIR_VIRTUAL_PATH,
+            absolutePath: workdir
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("does not mount workdir when it is inside workspace", ()=>{
+        const workdir = external_node_path_default().join(workspace, "outputs");
+        const mount = (0, agentInvoker_cjs_namespaceObject.resolveExternalOutputMount)(workspace, workdir, null);
+        (0, external_vitest_namespaceObject.expect)(mount).toEqual({
+            virtualPath: null,
+            absolutePath: null
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("mounts external default output when no workdir is set", ()=>{
+        const defaultOutputDir = external_node_path_default().resolve("external-default-output");
+        const mount = (0, agentInvoker_cjs_namespaceObject.resolveExternalOutputMount)(workspace, null, defaultOutputDir);
+        (0, external_vitest_namespaceObject.expect)(mount).toEqual({
+            virtualPath: agentInvoker_cjs_namespaceObject.OUTPUT_VIRTUAL_PATH,
+            absolutePath: defaultOutputDir
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("prefers workdir mount over default output mount", ()=>{
+        const workdir = external_node_path_default().resolve("outside", "session-output");
+        const defaultOutputDir = external_node_path_default().resolve("external-default-output");
+        const mount = (0, agentInvoker_cjs_namespaceObject.resolveExternalOutputMount)(workspace, workdir, defaultOutputDir);
+        (0, external_vitest_namespaceObject.expect)(mount).toEqual({
+            virtualPath: agentInvoker_cjs_namespaceObject.WORKDIR_VIRTUAL_PATH,
+            absolutePath: workdir
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("does not request an extra external mount when workdir is execution workspace", ()=>{
+        const executionWorkspace = external_node_path_default().resolve("outside", "session-output");
+        const mount = (0, agentInvoker_cjs_namespaceObject.resolveExternalOutputMount)(executionWorkspace, executionWorkspace, external_node_path_default().resolve("external-default-output"));
+        (0, external_vitest_namespaceObject.expect)(mount).toEqual({
+            virtualPath: null,
+            absolutePath: null
+        });
+    });
+});
+(0, external_vitest_namespaceObject.describe)("resolveExecutionWorkspace", ()=>{
+    const workspace = external_node_path_default().resolve("workspace");
+    (0, external_vitest_namespaceObject.it)("uses workspace when workdir is not set", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveExecutionWorkspace)(workspace, null)).toBe(external_node_path_default().normalize(workspace));
+    });
+    (0, external_vitest_namespaceObject.it)("resolves relative workdir from workspace", ()=>{
+        const resolved = (0, agentInvoker_cjs_namespaceObject.resolveExecutionWorkspace)(workspace, "outputs/session");
+        (0, external_vitest_namespaceObject.expect)(resolved).toBe(external_node_path_default().normalize(external_node_path_default().join(workspace, "outputs/session")));
+    });
+    (0, external_vitest_namespaceObject.it)("uses absolute workdir directly", ()=>{
+        const absolute = external_node_path_default().resolve("outside", "session-output");
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.resolveExecutionWorkspace)(workspace, absolute)).toBe(external_node_path_default().normalize(absolute));
+    });
+});
+(0, external_vitest_namespaceObject.describe)("toWorkspaceAliasVirtualPath", ()=>{
+    (0, external_vitest_namespaceObject.it)("builds an alias path for absolute workspaces", ()=>{
+        const absolute = external_node_path_default().resolve("outside", "session-output");
+        const alias = (0, agentInvoker_cjs_namespaceObject.toWorkspaceAliasVirtualPath)(absolute);
+        const expected = `/${absolute.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "")}/`;
+        (0, external_vitest_namespaceObject.expect)(alias).toBe(expected);
+    });
+    (0, external_vitest_namespaceObject.it)("returns null for non-absolute workspace paths", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, agentInvoker_cjs_namespaceObject.toWorkspaceAliasVirtualPath)("relative/workspace")).toBeNull();
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/agentInvokerWorkdir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/agentInvokerWorkdir.test.js

@@ -0,0 +1,72 @@
+import node_path from "node:path";
+import { describe, expect, it } from "vitest";
+import { OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, resolveExecutionWorkspace, resolveExternalOutputMount, toWorkspaceAliasVirtualPath } from "../cli/core/agentInvoker.js";
+describe("resolveExternalOutputMount", ()=>{
+    const workspace = node_path.resolve("workspace");
+    it("mounts external workdir paths", ()=>{
+        const workdir = node_path.resolve("outside", "session-output");
+        const mount = resolveExternalOutputMount(workspace, workdir, null);
+        expect(mount).toEqual({
+            virtualPath: WORKDIR_VIRTUAL_PATH,
+            absolutePath: workdir
+        });
+    });
+    it("does not mount workdir when it is inside workspace", ()=>{
+        const workdir = node_path.join(workspace, "outputs");
+        const mount = resolveExternalOutputMount(workspace, workdir, null);
+        expect(mount).toEqual({
+            virtualPath: null,
+            absolutePath: null
+        });
+    });
+    it("mounts external default output when no workdir is set", ()=>{
+        const defaultOutputDir = node_path.resolve("external-default-output");
+        const mount = resolveExternalOutputMount(workspace, null, defaultOutputDir);
+        expect(mount).toEqual({
+            virtualPath: OUTPUT_VIRTUAL_PATH,
+            absolutePath: defaultOutputDir
+        });
+    });
+    it("prefers workdir mount over default output mount", ()=>{
+        const workdir = node_path.resolve("outside", "session-output");
+        const defaultOutputDir = node_path.resolve("external-default-output");
+        const mount = resolveExternalOutputMount(workspace, workdir, defaultOutputDir);
+        expect(mount).toEqual({
+            virtualPath: WORKDIR_VIRTUAL_PATH,
+            absolutePath: workdir
+        });
+    });
+    it("does not request an extra external mount when workdir is execution workspace", ()=>{
+        const executionWorkspace = node_path.resolve("outside", "session-output");
+        const mount = resolveExternalOutputMount(executionWorkspace, executionWorkspace, node_path.resolve("external-default-output"));
+        expect(mount).toEqual({
+            virtualPath: null,
+            absolutePath: null
+        });
+    });
+});
+describe("resolveExecutionWorkspace", ()=>{
+    const workspace = node_path.resolve("workspace");
+    it("uses workspace when workdir is not set", ()=>{
+        expect(resolveExecutionWorkspace(workspace, null)).toBe(node_path.normalize(workspace));
+    });
+    it("resolves relative workdir from workspace", ()=>{
+        const resolved = resolveExecutionWorkspace(workspace, "outputs/session");
+        expect(resolved).toBe(node_path.normalize(node_path.join(workspace, "outputs/session")));
+    });
+    it("uses absolute workdir directly", ()=>{
+        const absolute = node_path.resolve("outside", "session-output");
+        expect(resolveExecutionWorkspace(workspace, absolute)).toBe(node_path.normalize(absolute));
+    });
+});
+describe("toWorkspaceAliasVirtualPath", ()=>{
+    it("builds an alias path for absolute workspaces", ()=>{
+        const absolute = node_path.resolve("outside", "session-output");
+        const alias = toWorkspaceAliasVirtualPath(absolute);
+        const expected = `/${absolute.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "")}/`;
+        expect(alias).toBe(expected);
+    });
+    it("returns null for non-absolute workspace paths", ()=>{
+        expect(toWorkspaceAliasVirtualPath("relative/workspace")).toBeNull();
+    });
+});