@wingman-ai/gateway 0.1.5 → 0.2.0

package/dist/cli/core/agentInvoker.js

@@ -1,6 +1,6 @@
 import { CompositeBackend, FilesystemBackend, createDeepAgent } from "deepagents";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join, normalize, sep } from "node:path";
 import { v4 } from "uuid";
 import { AgentLoader } from "../../agent/config/agentLoader.js";
 import { WingmanConfigLoader } from "../config/loader.js";
@@ -20,6 +20,40 @@ function _define_property(obj, key, value) {
     else obj[key] = value;
     return obj;
 }
+const WORKDIR_VIRTUAL_PATH = "/workdir/";
+const OUTPUT_VIRTUAL_PATH = "/output/";
+const isPathWithinRoot = (targetPath, rootPath)=>{
+    const normalizedTarget = normalize(targetPath);
+    const normalizedRoot = normalize(rootPath);
+    return normalizedTarget === normalizedRoot || normalizedTarget.startsWith(normalizedRoot + sep);
+};
+const resolveExecutionWorkspace = (workspace, workdir)=>{
+    if (!workdir) return normalize(workspace);
+    if (isAbsolute(workdir)) return normalize(workdir);
+    return normalize(join(workspace, workdir));
+};
+const toWorkspaceAliasVirtualPath = (absolutePath)=>{
+    const normalized = normalize(absolutePath);
+    if (!isAbsolute(normalized)) return null;
+    const posixPath = normalized.replace(/\\/g, "/");
+    const trimmed = posixPath.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!trimmed) return null;
+    return `/${trimmed}/`;
+};
+const resolveExternalOutputMount = (workspace, workdir, defaultOutputDir)=>{
+    if (workdir && !isPathWithinRoot(workdir, workspace)) return {
+        virtualPath: WORKDIR_VIRTUAL_PATH,
+        absolutePath: workdir
+    };
+    if (!workdir && defaultOutputDir && !isPathWithinRoot(defaultOutputDir, workspace)) return {
+        virtualPath: OUTPUT_VIRTUAL_PATH,
+        absolutePath: defaultOutputDir
+    };
+    return {
+        virtualPath: null,
+        absolutePath: null
+    };
+};
 class AgentInvoker {
     findAllAgents() {
         const agentConfigs = this.loader.loadAllAgentConfigs();
@@ -30,7 +64,10 @@ class AgentInvoker {
     }
     async invokeAgent(agentName, prompt, sessionId, attachments) {
         try {
-            const targetAgent = await this.findAgent(agentName);
+            const executionWorkspace = resolveExecutionWorkspace(this.workspace, this.workdir);
+            const effectiveWorkdir = this.workdir ? executionWorkspace : null;
+            const loader = normalize(executionWorkspace) === normalize(this.workspace) ? this.loader : new AgentLoader(this.configDir, this.workspace, this.wingmanConfig, executionWorkspace);
+            const targetAgent = await loader.loadAgent(agentName);
             if (!targetAgent) throw new Error(`Agent "${agentName}" not found`);
             this.logger.info(`Invoking agent: ${agentName}`);
             const preview = prompt.trim() || (attachments && attachments.length > 0 ? buildAttachmentPreview(attachments) : "");
@@ -58,43 +95,65 @@ class AgentInvoker {
                 }
             }
             const skillsDirectory = this.wingmanConfig?.skills?.skillsDirectory || "skills";
+            const normalizedSkillsDirectory = skillsDirectory.replace(/^\/+|\/+$/g, "");
+            const skillsVirtualPath = `/${normalizedSkillsDirectory}/`;
+            const outputMount = resolveExternalOutputMount(executionWorkspace, effectiveWorkdir, this.defaultOutputDir);
             const middleware = [
                 mediaCompatibilityMiddleware({
                     model: targetAgent.model
                 }),
                 additionalMessageMiddleware({
-                    workspaceRoot: this.workspace,
-                    workdir: this.workdir,
+                    workspaceRoot: executionWorkspace,
+                    workdir: effectiveWorkdir,
                     defaultOutputDir: this.defaultOutputDir,
+                    outputVirtualPath: outputMount.virtualPath,
                     dynamicUiEnabled: this.wingmanConfig?.gateway?.dynamicUiEnabled !== false,
                     skillsDirectory
                 })
             ];
             if (mergedHooks) {
                 this.logger.debug(`Adding hooks middleware with ${mergedHooks.PreToolUse?.length || 0} PreToolUse hooks, ${mergedHooks.PostToolUse?.length || 0} PostToolUse hooks, and ${mergedHooks.Stop?.length || 0} Stop hooks`);
-                middleware.push(createHooksMiddleware(mergedHooks, this.workspace, hookSessionId, this.logger));
+                middleware.push(createHooksMiddleware(mergedHooks, executionWorkspace, hookSessionId, this.logger));
             }
             const checkpointer = this.sessionManager?.getCheckpointer();
             const bundledSkillsPath = getBundledSkillsPath();
             const skillsSources = [];
             if (existsSync(bundledSkillsPath)) skillsSources.push("/skills-bundled/");
-            skillsSources.push(`/${skillsDirectory.replace(/^\/+|\/+$/g, "")}/`);
+            skillsSources.push(skillsVirtualPath);
             const backendOverrides = {
                 "/memories/": new FilesystemBackend({
                     rootDir: join(this.workspace, this.configDir, "memories"),
                     virtualMode: true
                 })
             };
+            const executionWorkspaceAlias = toWorkspaceAliasVirtualPath(executionWorkspace);
+            if (executionWorkspaceAlias) backendOverrides[executionWorkspaceAlias] = new FilesystemBackend({
+                rootDir: executionWorkspace,
+                virtualMode: true
+            });
+            if (effectiveWorkdir) backendOverrides[WORKDIR_VIRTUAL_PATH] = new FilesystemBackend({
+                rootDir: executionWorkspace,
+                virtualMode: true
+            });
+            const workspaceSkillsPath = join(this.workspace, normalizedSkillsDirectory);
+            if (existsSync(workspaceSkillsPath)) backendOverrides[skillsVirtualPath] = new FilesystemBackend({
+                rootDir: workspaceSkillsPath,
+                virtualMode: true
+            });
             if (existsSync(bundledSkillsPath)) backendOverrides["/skills-bundled/"] = new FilesystemBackend({
                 rootDir: bundledSkillsPath,
                 virtualMode: true
             });
+            if (outputMount.virtualPath && outputMount.absolutePath) backendOverrides[outputMount.virtualPath] = new FilesystemBackend({
+                rootDir: outputMount.absolutePath,
+                virtualMode: true
+            });
             const standaloneAgent = createDeepAgent({
                 systemPrompt: targetAgent.systemPrompt,
                 tools: targetAgent.tools,
                 model: targetAgent.model,
                 backend: ()=>new CompositeBackend(new FilesystemBackend({
-                        rootDir: this.workspace,
+                        rootDir: executionWorkspace,
                         virtualMode: true
                     }), backendOverrides),
                 middleware: middleware,
@@ -103,7 +162,7 @@ class AgentInvoker {
                 checkpointer: checkpointer
             });
             this.logger.debug("Agent created, sending message");
-            const userContent = buildUserContent(prompt, attachments);
+            const userContent = buildUserContent(prompt, attachments, targetAgent.model);
             if (this.sessionManager && sessionId) {
                 this.logger.debug(`Using streaming with session: ${sessionId}`);
                 const stream = await standaloneAgent.streamEvents({
@@ -187,7 +246,7 @@ class AgentInvoker {
         this.loader = new AgentLoader(this.configDir, this.workspace, this.wingmanConfig);
     }
 }
-function buildUserContent(prompt, attachments) {
+function buildUserContent(prompt, attachments, model) {
     const text = prompt?.trim() ?? "";
     if (!attachments || 0 === attachments.length) return text;
     const parts = [];
@@ -195,18 +254,32 @@ function buildUserContent(prompt, attachments) {
         type: "text",
         text
     });
-    for (const attachment of attachments)if (attachment?.dataUrl) {
-        if (isAudioAttachment(attachment)) {
-            const audioPart = buildAudioPart(attachment);
-            if (audioPart) parts.push(audioPart);
+    for (const attachment of attachments)if (attachment) {
+        if (isFileAttachment(attachment)) {
+            const nativePdfPart = buildNativePdfPart(attachment, model);
+            if (nativePdfPart) {
+                parts.push(nativePdfPart);
+                continue;
+            }
+            parts.push({
+                type: "text",
+                text: buildFileAttachmentText(attachment)
+            });
             continue;
         }
-        parts.push({
-            type: "image_url",
-            image_url: {
-                url: attachment.dataUrl
+        if (attachment.dataUrl) {
+            if (isAudioAttachment(attachment)) {
+                const audioPart = buildAudioPart(attachment);
+                if (audioPart) parts.push(audioPart);
+                continue;
             }
-        });
+            parts.push({
+                type: "image_url",
+                image_url: {
+                    url: attachment.dataUrl
+                }
+            });
+        }
     }
     if (0 === parts.length) {
         if (!text) throw new Error("Attachment payload is empty or invalid.");
@@ -214,12 +287,93 @@ function buildUserContent(prompt, attachments) {
     }
     return parts;
 }
+function supportsNativePdfInputs(model) {
+    if (!model || "object" != typeof model) return false;
+    try {
+        const profile = model.profile;
+        if (!profile || "object" != typeof profile) return false;
+        return true === profile.pdfInputs;
+    } catch  {
+        return false;
+    }
+}
+function isPdfName(name) {
+    return (name || "").trim().toLowerCase().endsWith(".pdf");
+}
+function resolveFileMimeType(attachment) {
+    const direct = attachment.mimeType?.trim().toLowerCase();
+    if (direct) return direct.split(";")[0] || "";
+    const parsed = parseDataUrl(attachment.dataUrl);
+    return (parsed.mimeType || "").trim().toLowerCase().split(";")[0] || "";
+}
+function buildFileMetadata(attachment, defaultName) {
+    const filename = attachment.name?.trim() || defaultName;
+    return {
+        filename,
+        name: filename,
+        title: filename
+    };
+}
+function buildNativePdfPart(attachment, model) {
+    if (!supportsNativePdfInputs(model)) return null;
+    const mimeType = resolveFileMimeType(attachment);
+    const isPdf = "application/pdf" === mimeType || isPdfName(attachment.name);
+    if (!isPdf) return null;
+    const metadata = buildFileMetadata(attachment, "document.pdf");
+    const parsed = parseDataUrl(attachment.dataUrl);
+    const useResponsesInputFile = shouldUseResponsesInputFile(model);
+    if (useResponsesInputFile) {
+        if (parsed.data) {
+            const fileDataMime = parsed.mimeType || mimeType || "application/pdf";
+            return {
+                type: "input_file",
+                file_data: `data:${fileDataMime};base64,${parsed.data}`,
+                filename: metadata.filename
+            };
+        }
+        const fileDataUrl = attachment.dataUrl?.trim();
+        if (!fileDataUrl || !fileDataUrl.startsWith("data:")) return null;
+        return {
+            type: "input_file",
+            file_data: fileDataUrl,
+            filename: metadata.filename
+        };
+    }
+    if (parsed.data) return {
+        type: "file",
+        source_type: "base64",
+        mime_type: parsed.mimeType || mimeType || "application/pdf",
+        data: parsed.data,
+        metadata
+    };
+    const url = attachment.dataUrl?.trim();
+    if (!url || !url.startsWith("data:")) return null;
+    return {
+        type: "file",
+        source_type: "url",
+        mime_type: mimeType || "application/pdf",
+        url,
+        metadata
+    };
+}
+function shouldUseResponsesInputFile(model) {
+    if (!model || "object" != typeof model) return false;
+    try {
+        const flag = model.useResponsesApi;
+        if ("boolean" == typeof flag) return flag;
+    } catch  {}
+    return false;
+}
 function isAudioAttachment(attachment) {
     if ("audio" === attachment.kind) return true;
     if (attachment.mimeType?.startsWith("audio/")) return true;
     if (attachment.dataUrl?.startsWith("data:audio/")) return true;
     return false;
 }
+function isFileAttachment(attachment) {
+    if ("file" === attachment.kind) return true;
+    return "string" == typeof attachment.textContent;
+}
 function buildAudioPart(attachment) {
     const parsed = parseDataUrl(attachment.dataUrl);
     const mimeType = attachment.mimeType || parsed.mimeType;
@@ -245,14 +399,36 @@ function parseDataUrl(dataUrl) {
         data: match[2]
     };
 }
+function buildFileAttachmentText(attachment) {
+    const name = attachment.name?.trim() || "file";
+    const mime = attachment.mimeType?.trim();
+    const sizeLabel = "number" == typeof attachment.size && attachment.size >= 0 ? `, ${attachment.size} bytes` : "";
+    const meta = mime || sizeLabel ? ` (${[
+        mime,
+        sizeLabel.replace(/^, /, "")
+    ].filter(Boolean).join(", ")})` : "";
+    const header = `[Attached file: ${name}${meta}]`;
+    const text = attachment.textContent?.trim();
+    if (!text) return `${header}\n[No extractable text content provided.]`;
+    return `${header}\n${text}`;
+}
 function buildAttachmentPreview(attachments) {
+    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;
+    }
+    if (hasFile && (hasAudio || hasImage)) return "[files and media]";
     if (hasAudio && hasImage) return "[attachments]";
+    if (hasFile) return "[file]";
     if (hasAudio) return "[audio]";
     if (hasImage) return "[image]";
     return "";
 }
-export { AgentInvoker, buildUserContent };
+export { AgentInvoker, OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, buildUserContent, resolveExecutionWorkspace, resolveExternalOutputMount, toWorkspaceAliasVirtualPath };

package/dist/cli/core/sessionManager.cjs

@@ -480,10 +480,15 @@ function extractAttachments(blocks) {
             continue;
         }
         const audioUrl = extractAudioUrl(block);
-        if (audioUrl) attachments.push({
-            kind: "audio",
-            dataUrl: audioUrl
-        });
+        if (audioUrl) {
+            attachments.push({
+                kind: "audio",
+                dataUrl: audioUrl
+            });
+            continue;
+        }
+        const fileAttachment = extractFileAttachment(block);
+        if (fileAttachment) attachments.push(fileAttachment);
     }
     return attachments;
 }
@@ -538,6 +543,90 @@ function extractAudioUrl(block) {
     }
     return null;
 }
+function parseDataUrlMime(dataUrl) {
+    if ("string" != typeof dataUrl || !dataUrl.startsWith("data:")) return;
+    const match = dataUrl.match(/^data:([^;,]+)[;,]/i);
+    return match?.[1];
+}
+function extractString(...values) {
+    for (const value of values)if ("string" == typeof value && value.trim().length > 0) return value.trim();
+}
+function extractFileAttachment(block) {
+    if (!block || "object" != typeof block) return null;
+    if ("file" === block.type) {
+        const sourceType = block.source_type || block.sourceType;
+        const metadata = block.metadata && "object" == typeof block.metadata ? block.metadata : {};
+        const name = extractString(block.name, block.filename, metadata.filename, metadata.name, metadata.title);
+        const declaredMime = extractString(block.mime_type, block.mimeType, block.media_type, block.mediaType);
+        if ("base64" === sourceType && "string" == typeof block.data) {
+            const mimeType = declaredMime || "application/octet-stream";
+            return {
+                kind: "file",
+                dataUrl: `data:${mimeType};base64,${block.data}`,
+                name,
+                mimeType
+            };
+        }
+        if ("url" === sourceType && "string" == typeof block.url) {
+            const mimeType = declaredMime || parseDataUrlMime(block.url);
+            return {
+                kind: "file",
+                dataUrl: block.url,
+                name,
+                mimeType
+            };
+        }
+        const openAiFile = block.file;
+        if (openAiFile && "object" == typeof openAiFile) {
+            const fileData = extractString(openAiFile.file_data, openAiFile.data);
+            const fileUrl = extractString(openAiFile.file_url, openAiFile.url);
+            const fileName = extractString(openAiFile.filename, name);
+            if (fileData) return {
+                kind: "file",
+                dataUrl: fileData,
+                name: fileName,
+                mimeType: parseDataUrlMime(fileData)
+            };
+            if (fileUrl) return {
+                kind: "file",
+                dataUrl: fileUrl,
+                name: fileName,
+                mimeType: parseDataUrlMime(fileUrl)
+            };
+        }
+    }
+    if ("input_file" === block.type) {
+        const dataUrl = extractString(block.file_data, block.file_url);
+        if (!dataUrl) return null;
+        return {
+            kind: "file",
+            dataUrl,
+            name: extractString(block.filename),
+            mimeType: parseDataUrlMime(dataUrl)
+        };
+    }
+    if ("document" === block.type && block.source && "object" == typeof block.source) {
+        const source = block.source;
+        const sourceType = extractString(source.type);
+        const name = extractString(block.title);
+        if ("base64" === sourceType && "string" == typeof source.data) {
+            const mimeType = extractString(source.media_type, "application/pdf");
+            return {
+                kind: "file",
+                dataUrl: `data:${mimeType};base64,${source.data}`,
+                name,
+                mimeType
+            };
+        }
+        if ("url" === sourceType && "string" == typeof source.url) return {
+            kind: "file",
+            dataUrl: source.url,
+            name,
+            mimeType: parseDataUrlMime(source.url)
+        };
+    }
+    return null;
+}
 function resolveAudioMimeType(format) {
     const normalized = format.toLowerCase();
     switch(normalized){

package/dist/cli/core/sessionManager.d.ts

@@ -30,7 +30,7 @@ export interface SessionMessage {
     uiTextFallback?: string;
 }
 export interface SessionAttachment {
-    kind: "image" | "audio";
+    kind: "image" | "audio" | "file";
     dataUrl: string;
     name?: string;
     mimeType?: string;

package/dist/cli/core/sessionManager.js

@@ -447,10 +447,15 @@ function extractAttachments(blocks) {
             continue;
         }
         const audioUrl = extractAudioUrl(block);
-        if (audioUrl) attachments.push({
-            kind: "audio",
-            dataUrl: audioUrl
-        });
+        if (audioUrl) {
+            attachments.push({
+                kind: "audio",
+                dataUrl: audioUrl
+            });
+            continue;
+        }
+        const fileAttachment = extractFileAttachment(block);
+        if (fileAttachment) attachments.push(fileAttachment);
     }
     return attachments;
 }
@@ -505,6 +510,90 @@ function extractAudioUrl(block) {
     }
     return null;
 }
+function parseDataUrlMime(dataUrl) {
+    if ("string" != typeof dataUrl || !dataUrl.startsWith("data:")) return;
+    const match = dataUrl.match(/^data:([^;,]+)[;,]/i);
+    return match?.[1];
+}
+function extractString(...values) {
+    for (const value of values)if ("string" == typeof value && value.trim().length > 0) return value.trim();
+}
+function extractFileAttachment(block) {
+    if (!block || "object" != typeof block) return null;
+    if ("file" === block.type) {
+        const sourceType = block.source_type || block.sourceType;
+        const metadata = block.metadata && "object" == typeof block.metadata ? block.metadata : {};
+        const name = extractString(block.name, block.filename, metadata.filename, metadata.name, metadata.title);
+        const declaredMime = extractString(block.mime_type, block.mimeType, block.media_type, block.mediaType);
+        if ("base64" === sourceType && "string" == typeof block.data) {
+            const mimeType = declaredMime || "application/octet-stream";
+            return {
+                kind: "file",
+                dataUrl: `data:${mimeType};base64,${block.data}`,
+                name,
+                mimeType
+            };
+        }
+        if ("url" === sourceType && "string" == typeof block.url) {
+            const mimeType = declaredMime || parseDataUrlMime(block.url);
+            return {
+                kind: "file",
+                dataUrl: block.url,
+                name,
+                mimeType
+            };
+        }
+        const openAiFile = block.file;
+        if (openAiFile && "object" == typeof openAiFile) {
+            const fileData = extractString(openAiFile.file_data, openAiFile.data);
+            const fileUrl = extractString(openAiFile.file_url, openAiFile.url);
+            const fileName = extractString(openAiFile.filename, name);
+            if (fileData) return {
+                kind: "file",
+                dataUrl: fileData,
+                name: fileName,
+                mimeType: parseDataUrlMime(fileData)
+            };
+            if (fileUrl) return {
+                kind: "file",
+                dataUrl: fileUrl,
+                name: fileName,
+                mimeType: parseDataUrlMime(fileUrl)
+            };
+        }
+    }
+    if ("input_file" === block.type) {
+        const dataUrl = extractString(block.file_data, block.file_url);
+        if (!dataUrl) return null;
+        return {
+            kind: "file",
+            dataUrl,
+            name: extractString(block.filename),
+            mimeType: parseDataUrlMime(dataUrl)
+        };
+    }
+    if ("document" === block.type && block.source && "object" == typeof block.source) {
+        const source = block.source;
+        const sourceType = extractString(source.type);
+        const name = extractString(block.title);
+        if ("base64" === sourceType && "string" == typeof source.data) {
+            const mimeType = extractString(source.media_type, "application/pdf");
+            return {
+                kind: "file",
+                dataUrl: `data:${mimeType};base64,${source.data}`,
+                name,
+                mimeType
+            };
+        }
+        if ("url" === sourceType && "string" == typeof source.url) return {
+            kind: "file",
+            dataUrl: source.url,
+            name,
+            mimeType: parseDataUrlMime(source.url)
+        };
+    }
+    return null;
+}
 function resolveAudioMimeType(format) {
     const normalized = format.toLowerCase();
     switch(normalized){