@wingman-ai/gateway 0.1.4 → 0.2.0

package/dist/agent/tests/modelFactory.test.cjs

@@ -4,6 +4,14 @@ const external_vitest_namespaceObject = require("vitest");
 const modelFactory_cjs_namespaceObject = require("../config/modelFactory.cjs");
 const anthropic_namespaceObject = require("@langchain/anthropic");
 const openai_namespaceObject = require("@langchain/openai");
+const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
+(0, external_vitest_namespaceObject.beforeEach)(()=>{
+    process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
+});
+(0, external_vitest_namespaceObject.afterEach)(()=>{
+    if (void 0 === originalAnthropicApiKey) return void delete process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = originalAnthropicApiKey;
+});
 (0, external_vitest_namespaceObject.describe)("ModelFactory", ()=>{
     (0, external_vitest_namespaceObject.describe)("createModel", ()=>{
         (0, external_vitest_namespaceObject.it)("should create an Anthropic model", ()=>{
@@ -14,6 +22,11 @@ const openai_namespaceObject = require("@langchain/openai");
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-4o");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
         });
+        (0, external_vitest_namespaceObject.it)("should force OpenAI models onto the responses API", ()=>{
+            const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openai:gpt-5.2-codex");
+            (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);
+            (0, external_vitest_namespaceObject.expect)(model.useResponsesApi).toBe(true);
+        });
         (0, external_vitest_namespaceObject.it)("should create an OpenRouter model", ()=>{
             const model = modelFactory_cjs_namespaceObject.ModelFactory.createModel("openrouter:openai/gpt-4o");
             (0, external_vitest_namespaceObject.expect)(model).toBeInstanceOf(openai_namespaceObject.ChatOpenAI);

package/dist/agent/tests/modelFactory.test.js

@@ -1,7 +1,15 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import { ModelFactory } from "../config/modelFactory.js";
 import { ChatAnthropic } from "@langchain/anthropic";
 import { ChatOpenAI } from "@langchain/openai";
+const originalAnthropicApiKey = process.env.ANTHROPIC_API_KEY;
+beforeEach(()=>{
+    process.env.ANTHROPIC_API_KEY = "test-anthropic-api-key";
+});
+afterEach(()=>{
+    if (void 0 === originalAnthropicApiKey) return void delete process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = originalAnthropicApiKey;
+});
 describe("ModelFactory", ()=>{
     describe("createModel", ()=>{
         it("should create an Anthropic model", ()=>{
@@ -12,6 +20,11 @@ describe("ModelFactory", ()=>{
             const model = ModelFactory.createModel("openai:gpt-4o");
             expect(model).toBeInstanceOf(ChatOpenAI);
         });
+        it("should force OpenAI models onto the responses API", ()=>{
+            const model = ModelFactory.createModel("openai:gpt-5.2-codex");
+            expect(model).toBeInstanceOf(ChatOpenAI);
+            expect(model.useResponsesApi).toBe(true);
+        });
         it("should create an OpenRouter model", ()=>{
             const model = ModelFactory.createModel("openrouter:openai/gpt-4o");
             expect(model).toBeInstanceOf(ChatOpenAI);

package/dist/agent/tests/toolRegistry.test.cjs

@@ -1,6 +1,9 @@
 "use strict";
 var __webpack_exports__ = {};
 const external_vitest_namespaceObject = require("vitest");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_os_namespaceObject = require("node:os");
 const toolRegistry_cjs_namespaceObject = require("../config/toolRegistry.cjs");
 (0, external_vitest_namespaceObject.describe)("Tool Registry", ()=>{
     (0, external_vitest_namespaceObject.describe)("createTool", ()=>{
@@ -32,6 +35,18 @@ const toolRegistry_cjs_namespaceObject = require("../config/toolRegistry.cjs");
             (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
             (0, external_vitest_namespaceObject.expect)(tool?.name).toBe("command_execute");
         });
+        (0, external_vitest_namespaceObject.it)("should execute command tools in executionWorkspace when provided", async ()=>{
+            const executionWorkspace = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-tool-workspace-"));
+            const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("command_execute", {
+                workspace: "/custom/path",
+                executionWorkspace
+            });
+            (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();
+            const result = await tool.invoke({
+                command: 'node -e "process.stdout.write(process.cwd())"'
+            });
+            (0, external_vitest_namespaceObject.expect)(String(result)).toContain(executionWorkspace);
+        });
         (0, external_vitest_namespaceObject.it)("should create think tool", ()=>{
             const tool = (0, toolRegistry_cjs_namespaceObject.createTool)("think");
             (0, external_vitest_namespaceObject.expect)(tool).not.toBeNull();

package/dist/agent/tests/toolRegistry.test.js

@@ -1,4 +1,7 @@
 import { describe, expect, it } from "vitest";
+import { mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { createTool, createTools, getAvailableTools } from "../config/toolRegistry.js";
 describe("Tool Registry", ()=>{
     describe("createTool", ()=>{
@@ -30,6 +33,18 @@ describe("Tool Registry", ()=>{
             expect(tool).not.toBeNull();
             expect(tool?.name).toBe("command_execute");
         });
+        it("should execute command tools in executionWorkspace when provided", async ()=>{
+            const executionWorkspace = mkdtempSync(join(tmpdir(), "wingman-tool-workspace-"));
+            const tool = createTool("command_execute", {
+                workspace: "/custom/path",
+                executionWorkspace
+            });
+            expect(tool).not.toBeNull();
+            const result = await tool.invoke({
+                command: 'node -e "process.stdout.write(process.cwd())"'
+            });
+            expect(String(result)).toContain(executionWorkspace);
+        });
         it("should create think tool", ()=>{
             const tool = createTool("think");
             expect(tool).not.toBeNull();

package/dist/agent/tests/uiRegistryTools.test.cjs

@@ -55,6 +55,21 @@ const skillsDir = "skills";
             (0, external_vitest_namespaceObject.expect)(result.propsSchema).toBeTruthy();
         }
     });
+    (0, external_vitest_namespaceObject.it)("exposes axis scale options for chart components", async ()=>{
+        const tool = (0, ui_registry_cjs_namespaceObject.createUiRegistryGetTool)(workspace, skillsDir);
+        for (const componentId of [
+            "line_chart",
+            "area_chart",
+            "bar_chart"
+        ]){
+            const result = await tool.invoke({
+                componentId
+            });
+            const props = result.propsSchema?.properties ?? {};
+            (0, external_vitest_namespaceObject.expect)(props.xScale).toBeTruthy();
+            (0, external_vitest_namespaceObject.expect)(props.yScale).toBeTruthy();
+        }
+    });
     (0, external_vitest_namespaceObject.it)("renders UI payload when enabled", async ()=>{
         const tool = (0, ui_registry_cjs_namespaceObject.createUiPresentTool)(workspace, skillsDir, true);
         const result = await tool.invoke({

package/dist/agent/tests/uiRegistryTools.test.js

@@ -50,6 +50,21 @@ describe("UI Registry Tools", ()=>{
             expect(result.propsSchema).toBeTruthy();
         }
     });
+    it("exposes axis scale options for chart components", async ()=>{
+        const tool = createUiRegistryGetTool(workspace, skillsDir);
+        for (const componentId of [
+            "line_chart",
+            "area_chart",
+            "bar_chart"
+        ]){
+            const result = await tool.invoke({
+                componentId
+            });
+            const props = result.propsSchema?.properties ?? {};
+            expect(props.xScale).toBeTruthy();
+            expect(props.yScale).toBeTruthy();
+        }
+    });
     it("renders UI payload when enabled", async ()=>{
         const tool = createUiPresentTool(workspace, skillsDir, true);
         const result = await tool.invoke({

package/dist/agent/tools/code_search.cjs

@@ -92,7 +92,7 @@ const createCodeSearchTool = (workspace)=>{
         description: "Search code patterns across the codebase using ripgrep (or grep as fallback). Fast and efficient for finding function definitions, variables, imports, or any text pattern. Returns file paths with line numbers and context.",
         schema: external_zod_namespaceObject.z.object({
             pattern: external_zod_namespaceObject.z.string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
-            path: external_zod_namespaceObject.z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to entire workspace."),
+            path: external_zod_namespaceObject.z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to the active execution workspace."),
             type: external_zod_namespaceObject.z.string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
             context: external_zod_namespaceObject.z.number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
             caseSensitive: external_zod_namespaceObject.z.boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")

package/dist/agent/tools/code_search.js

@@ -64,7 +64,7 @@ const createCodeSearchTool = (workspace)=>{
         description: "Search code patterns across the codebase using ripgrep (or grep as fallback). Fast and efficient for finding function definitions, variables, imports, or any text pattern. Returns file paths with line numbers and context.",
         schema: z.object({
             pattern: z.string().describe("The pattern to search for (regex or literal string). Examples: 'function.*processData', 'import.*React', 'TODO'"),
-            path: z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to entire workspace."),
+            path: z.string().optional().describe("Optional: Directory or file to search in (e.g., 'src/', 'src/utils.ts'). Defaults to the active execution workspace."),
             type: z.string().optional().describe("Optional: File type filter (e.g., 'ts', 'js', 'py', 'go'). Searches only files of this type."),
             context: z.number().optional().default(2).describe("Optional: Number of context lines to show around matches. Default is 2."),
             caseSensitive: z.boolean().optional().default(false).describe("Optional: Whether search should be case-sensitive.")

package/dist/agent/tools/command_execute.cjs

@@ -120,7 +120,7 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
             }
         }), {
         name: "command_execute",
-        description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the workspace context.",
+        description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the active execution workspace context.",
         schema: external_zod_namespaceObject.z.object({
             command: external_zod_namespaceObject.z.string().describe("The command to execute in the terminal")
         })

package/dist/agent/tools/command_execute.js

@@ -91,7 +91,7 @@ const createCommandExecuteTool = (workspace, envVariables, blockedCommands = DEF
             }
         }), {
         name: "command_execute",
-        description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the workspace context.",
+        description: "Executes a command in a terminal and reports the output. Cannot execute potentially destructive commands like rm, mv, chmod, sudo, etc. Use for safe operations like running tests, builds, or other validation commands. Do not run long-running commands like dev servers. Commands run with a timeout in the active execution workspace context.",
         schema: z.object({
             command: z.string().describe("The command to execute in the terminal")
         })

package/dist/agent/tools/ui_registry.d.ts

@@ -37,9 +37,9 @@ export declare const createUiPresentTool: (workspace: string, skillsDirectory: s
         gap: z.ZodOptional<z.ZodNumber>;
         columns: z.ZodOptional<z.ZodNumber>;
         align: z.ZodOptional<z.ZodEnum<{
-            end: "end";
             start: "start";
             center: "center";
+            end: "end";
             stretch: "stretch";
         }>>;
     }, z.core.$strip>>;
@@ -54,7 +54,7 @@ export declare const createUiPresentTool: (workspace: string, skillsDirectory: s
         type: "stack" | "row" | "grid";
         gap?: number | undefined;
         columns?: number | undefined;
-        align?: "end" | "start" | "center" | "stretch" | undefined;
+        align?: "start" | "center" | "end" | "stretch" | undefined;
     } | undefined;
 }, {
     componentId: string;
@@ -64,7 +64,7 @@ export declare const createUiPresentTool: (workspace: string, skillsDirectory: s
         type: "stack" | "row" | "grid";
         gap?: number | undefined;
         columns?: number | undefined;
-        align?: "end" | "start" | "center" | "stretch" | undefined;
+        align?: "start" | "center" | "end" | "stretch" | undefined;
     } | undefined;
     uiOnly?: boolean | undefined;
 }, Record<string, any>, "ui_present">;

package/dist/cli/core/agentInvoker.cjs

@@ -24,8 +24,13 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    resolveExternalOutputMount: ()=>resolveExternalOutputMount,
+    toWorkspaceAliasVirtualPath: ()=>toWorkspaceAliasVirtualPath,
+    OUTPUT_VIRTUAL_PATH: ()=>OUTPUT_VIRTUAL_PATH,
+    WORKDIR_VIRTUAL_PATH: ()=>WORKDIR_VIRTUAL_PATH,
+    AgentInvoker: ()=>AgentInvoker,
     buildUserContent: ()=>buildUserContent,
-    AgentInvoker: ()=>AgentInvoker
+    resolveExecutionWorkspace: ()=>resolveExecutionWorkspace
 });
 const external_deepagents_namespaceObject = require("deepagents");
 const external_node_fs_namespaceObject = require("node:fs");
@@ -49,6 +54,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 = (0, external_node_path_namespaceObject.normalize)(targetPath);
+    const normalizedRoot = (0, external_node_path_namespaceObject.normalize)(rootPath);
+    return normalizedTarget === normalizedRoot || normalizedTarget.startsWith(normalizedRoot + external_node_path_namespaceObject.sep);
+};
+const resolveExecutionWorkspace = (workspace, workdir)=>{
+    if (!workdir) return (0, external_node_path_namespaceObject.normalize)(workspace);
+    if ((0, external_node_path_namespaceObject.isAbsolute)(workdir)) return (0, external_node_path_namespaceObject.normalize)(workdir);
+    return (0, external_node_path_namespaceObject.normalize)((0, external_node_path_namespaceObject.join)(workspace, workdir));
+};
+const toWorkspaceAliasVirtualPath = (absolutePath)=>{
+    const normalized = (0, external_node_path_namespaceObject.normalize)(absolutePath);
+    if (!(0, external_node_path_namespaceObject.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();
@@ -59,7 +98,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 = (0, external_node_path_namespaceObject.normalize)(executionWorkspace) === (0, external_node_path_namespaceObject.normalize)(this.workspace) ? this.loader : new agentLoader_cjs_namespaceObject.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) : "");
@@ -87,43 +129,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 = [
                 (0, media_compat_cjs_namespaceObject.mediaCompatibilityMiddleware)({
                     model: targetAgent.model
                 }),
                 (0, additional_messages_cjs_namespaceObject.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((0, hooks_cjs_namespaceObject.createHooksMiddleware)(mergedHooks, this.workspace, hookSessionId, this.logger));
+                middleware.push((0, hooks_cjs_namespaceObject.createHooksMiddleware)(mergedHooks, executionWorkspace, hookSessionId, this.logger));
             }
             const checkpointer = this.sessionManager?.getCheckpointer();
             const bundledSkillsPath = (0, uiRegistry_cjs_namespaceObject.getBundledSkillsPath)();
             const skillsSources = [];
             if ((0, external_node_fs_namespaceObject.existsSync)(bundledSkillsPath)) skillsSources.push("/skills-bundled/");
-            skillsSources.push(`/${skillsDirectory.replace(/^\/+|\/+$/g, "")}/`);
+            skillsSources.push(skillsVirtualPath);
             const backendOverrides = {
                 "/memories/": new external_deepagents_namespaceObject.FilesystemBackend({
                     rootDir: (0, external_node_path_namespaceObject.join)(this.workspace, this.configDir, "memories"),
                     virtualMode: true
                 })
             };
+            const executionWorkspaceAlias = toWorkspaceAliasVirtualPath(executionWorkspace);
+            if (executionWorkspaceAlias) backendOverrides[executionWorkspaceAlias] = new external_deepagents_namespaceObject.FilesystemBackend({
+                rootDir: executionWorkspace,
+                virtualMode: true
+            });
+            if (effectiveWorkdir) backendOverrides[WORKDIR_VIRTUAL_PATH] = new external_deepagents_namespaceObject.FilesystemBackend({
+                rootDir: executionWorkspace,
+                virtualMode: true
+            });
+            const workspaceSkillsPath = (0, external_node_path_namespaceObject.join)(this.workspace, normalizedSkillsDirectory);
+            if ((0, external_node_fs_namespaceObject.existsSync)(workspaceSkillsPath)) backendOverrides[skillsVirtualPath] = new external_deepagents_namespaceObject.FilesystemBackend({
+                rootDir: workspaceSkillsPath,
+                virtualMode: true
+            });
             if ((0, external_node_fs_namespaceObject.existsSync)(bundledSkillsPath)) backendOverrides["/skills-bundled/"] = new external_deepagents_namespaceObject.FilesystemBackend({
                 rootDir: bundledSkillsPath,
                 virtualMode: true
             });
+            if (outputMount.virtualPath && outputMount.absolutePath) backendOverrides[outputMount.virtualPath] = new external_deepagents_namespaceObject.FilesystemBackend({
+                rootDir: outputMount.absolutePath,
+                virtualMode: true
+            });
             const standaloneAgent = (0, external_deepagents_namespaceObject.createDeepAgent)({
                 systemPrompt: targetAgent.systemPrompt,
                 tools: targetAgent.tools,
                 model: targetAgent.model,
                 backend: ()=>new external_deepagents_namespaceObject.CompositeBackend(new external_deepagents_namespaceObject.FilesystemBackend({
-                        rootDir: this.workspace,
+                        rootDir: executionWorkspace,
                         virtualMode: true
                     }), backendOverrides),
                 middleware: middleware,
@@ -132,7 +196,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({
@@ -216,7 +280,7 @@ class AgentInvoker {
         this.loader = new agentLoader_cjs_namespaceObject.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 = [];
@@ -224,18 +288,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.");
@@ -243,12 +321,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;
@@ -274,21 +433,53 @@ 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 "";
 }
 exports.AgentInvoker = __webpack_exports__.AgentInvoker;
+exports.OUTPUT_VIRTUAL_PATH = __webpack_exports__.OUTPUT_VIRTUAL_PATH;
+exports.WORKDIR_VIRTUAL_PATH = __webpack_exports__.WORKDIR_VIRTUAL_PATH;
 exports.buildUserContent = __webpack_exports__.buildUserContent;
+exports.resolveExecutionWorkspace = __webpack_exports__.resolveExecutionWorkspace;
+exports.resolveExternalOutputMount = __webpack_exports__.resolveExternalOutputMount;
+exports.toWorkspaceAliasVirtualPath = __webpack_exports__.toWorkspaceAliasVirtualPath;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "AgentInvoker",
-    "buildUserContent"
+    "OUTPUT_VIRTUAL_PATH",
+    "WORKDIR_VIRTUAL_PATH",
+    "buildUserContent",
+    "resolveExecutionWorkspace",
+    "resolveExternalOutputMount",
+    "toWorkspaceAliasVirtualPath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true