@wingman-ai/gateway 0.2.4 → 0.3.0

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

@@ -0,0 +1,124 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const mcpClientManager_cjs_namespaceObject = require("../config/mcpClientManager.cjs");
+const testLogger = {
+    debug: ()=>{},
+    info: ()=>{},
+    warn: ()=>{},
+    error: ()=>{}
+};
+const getClientConfig = (manager)=>manager.buildClientConfig();
+(0, external_vitest_namespaceObject.describe)("MCPClientManager runtime env", ()=>{
+    (0, external_vitest_namespaceObject.it)("injects workdir for stdio servers", ()=>{
+        const executionWorkspace = "/tmp/wingman-workdir";
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(configs, testLogger, {
+            executionWorkspace
+        });
+        const clientConfig = getClientConfig(manager);
+        const env = clientConfig.mcpServers["fal-ai"].env;
+        (0, external_vitest_namespaceObject.expect)(env.EXISTING).toBe("value");
+        (0, external_vitest_namespaceObject.expect)(env.WINGMAN_WORKDIR).toBe(executionWorkspace);
+    });
+    (0, external_vitest_namespaceObject.it)("does not inject workdir when no execution workspace is provided", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(configs, testLogger);
+        const clientConfig = getClientConfig(manager);
+        const env = clientConfig.mcpServers["fal-ai"].env;
+        (0, external_vitest_namespaceObject.expect)(env.EXISTING).toBe("value");
+        (0, external_vitest_namespaceObject.expect)(env.WINGMAN_WORKDIR).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("resolves env placeholders", ()=>{
+        const original = process.env.FAL_API_KEY;
+        process.env.FAL_API_KEY = "test-key";
+        try {
+            const configs = [
+                {
+                    servers: [
+                        {
+                            name: "fal-ai",
+                            transport: "stdio",
+                            command: "bun",
+                            args: [
+                                "run",
+                                "src/tools/mcp-fal-ai.ts"
+                            ],
+                            env: {
+                                FAL_API_KEY: "${FAL_API_KEY}"
+                            }
+                        }
+                    ]
+                }
+            ];
+            const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(configs, testLogger);
+            const clientConfig = getClientConfig(manager);
+            (0, external_vitest_namespaceObject.expect)(clientConfig.mcpServers["fal-ai"].env.FAL_API_KEY).toBe("test-key");
+        } finally{
+            if ("string" == typeof original) process.env.FAL_API_KEY = original;
+            else delete process.env.FAL_API_KEY;
+        }
+    });
+    (0, external_vitest_namespaceObject.it)("passes through per-server default tool timeout", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        defaultToolTimeout: 300000,
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(configs, testLogger);
+        const clientConfig = getClientConfig(manager);
+        (0, external_vitest_namespaceObject.expect)(clientConfig.mcpServers["fal-ai"].defaultToolTimeout).toBe(300000);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tests/mcpClientManager.test.d.ts

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

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

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { MCPClientManager } from "../config/mcpClientManager.js";
+const testLogger = {
+    debug: ()=>{},
+    info: ()=>{},
+    warn: ()=>{},
+    error: ()=>{}
+};
+const getClientConfig = (manager)=>manager.buildClientConfig();
+describe("MCPClientManager runtime env", ()=>{
+    it("injects workdir for stdio servers", ()=>{
+        const executionWorkspace = "/tmp/wingman-workdir";
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new MCPClientManager(configs, testLogger, {
+            executionWorkspace
+        });
+        const clientConfig = getClientConfig(manager);
+        const env = clientConfig.mcpServers["fal-ai"].env;
+        expect(env.EXISTING).toBe("value");
+        expect(env.WINGMAN_WORKDIR).toBe(executionWorkspace);
+    });
+    it("does not inject workdir when no execution workspace is provided", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new MCPClientManager(configs, testLogger);
+        const clientConfig = getClientConfig(manager);
+        const env = clientConfig.mcpServers["fal-ai"].env;
+        expect(env.EXISTING).toBe("value");
+        expect(env.WINGMAN_WORKDIR).toBeUndefined();
+    });
+    it("resolves env placeholders", ()=>{
+        const original = process.env.FAL_API_KEY;
+        process.env.FAL_API_KEY = "test-key";
+        try {
+            const configs = [
+                {
+                    servers: [
+                        {
+                            name: "fal-ai",
+                            transport: "stdio",
+                            command: "bun",
+                            args: [
+                                "run",
+                                "src/tools/mcp-fal-ai.ts"
+                            ],
+                            env: {
+                                FAL_API_KEY: "${FAL_API_KEY}"
+                            }
+                        }
+                    ]
+                }
+            ];
+            const manager = new MCPClientManager(configs, testLogger);
+            const clientConfig = getClientConfig(manager);
+            expect(clientConfig.mcpServers["fal-ai"].env.FAL_API_KEY).toBe("test-key");
+        } finally{
+            if ("string" == typeof original) process.env.FAL_API_KEY = original;
+            else delete process.env.FAL_API_KEY;
+        }
+    });
+    it("passes through per-server default tool timeout", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ],
+                        defaultToolTimeout: 300000,
+                        env: {
+                            EXISTING: "value"
+                        }
+                    }
+                ]
+            }
+        ];
+        const manager = new MCPClientManager(configs, testLogger);
+        const clientConfig = getClientConfig(manager);
+        expect(clientConfig.mcpServers["fal-ai"].defaultToolTimeout).toBe(300000);
+    });
+});

package/dist/agent/tools/command_execute.cjs

@@ -135,7 +135,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 active execution 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. Not for image generation/editing requests when dedicated image tools are available. Do not run long-running commands like dev servers. Commands run with a timeout in the active execution workspace context.",
         schema: external_zod_namespaceObject.object({
             command: external_zod_namespaceObject.string().describe("The command to execute in the terminal")
         })

package/dist/agent/tools/command_execute.js

@@ -106,7 +106,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 active execution 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. Not for image generation/editing requests when dedicated image tools are available. Do not run long-running commands like dev servers. Commands run with a timeout in the active execution workspace context.",
         schema: object({
             command: string().describe("The command to execute in the terminal")
         })

package/dist/cli/config/schema.d.ts

@@ -339,12 +339,14 @@ export declare const WingmanConfigSchema: z.ZodObject<{
         servers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             transport: z.ZodLiteral<"stdio">;
+            defaultToolTimeout: z.ZodOptional<z.ZodNumber>;
             command: z.ZodString;
             args: z.ZodOptional<z.ZodArray<z.ZodString>>;
             env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strip>, z.ZodObject<{
             name: z.ZodString;
             transport: z.ZodLiteral<"sse">;
+            defaultToolTimeout: z.ZodOptional<z.ZodNumber>;
             url: z.ZodString;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strip>]>>>;

package/dist/cli/core/agentInvoker.cjs

@@ -26,7 +26,9 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     resolveToolRetryMiddlewareSettings: ()=>resolveToolRetryMiddlewareSettings,
     resolveSummarizationMiddlewareSettings: ()=>resolveSummarizationMiddlewareSettings,
+    resolveAgentMemorySources: ()=>resolveAgentMemorySources,
     OUTPUT_VIRTUAL_PATH: ()=>OUTPUT_VIRTUAL_PATH,
+    emitCompletionAndContinuePostProcessing: ()=>emitCompletionAndContinuePostProcessing,
     resolveExecutionWorkspace: ()=>resolveExecutionWorkspace,
     buildUserContent: ()=>buildUserContent,
     detectStreamErrorMessage: ()=>detectStreamErrorMessage,
@@ -34,15 +36,16 @@ __webpack_require__.d(__webpack_exports__, {
     chunkHasAssistantText: ()=>chunkHasAssistantText,
     resolveModelRetryMiddlewareSettings: ()=>resolveModelRetryMiddlewareSettings,
     AgentInvoker: ()=>AgentInvoker,
-    WORKDIR_VIRTUAL_PATH: ()=>WORKDIR_VIRTUAL_PATH,
     configureDeepAgentSummarizationMiddleware: ()=>configureDeepAgentSummarizationMiddleware,
+    WORKDIR_VIRTUAL_PATH: ()=>WORKDIR_VIRTUAL_PATH,
     detectToolEventContext: ()=>detectToolEventContext,
     resolveExternalOutputMount: ()=>resolveExternalOutputMount,
-    evaluateStreamingCompletion: ()=>evaluateStreamingCompletion,
     resolveHumanInTheLoopSettings: ()=>resolveHumanInTheLoopSettings,
     trackRootLangGraphRunId: ()=>trackRootLangGraphRunId,
     isRootLangGraphTerminalEvent: ()=>isRootLangGraphTerminalEvent,
-    selectStreamingFallbackText: ()=>selectStreamingFallbackText
+    selectStreamingFallbackText: ()=>selectStreamingFallbackText,
+    AGENTS_MEMORY_VIRTUAL_PATHS: ()=>AGENTS_MEMORY_VIRTUAL_PATHS,
+    resolveAgentExecutionWorkspace: ()=>resolveAgentExecutionWorkspace
 });
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_path_namespaceObject = require("node:path");
@@ -70,6 +73,9 @@ function _define_property(obj, key, value) {
 }
 const WORKDIR_VIRTUAL_PATH = "/workdir/";
 const OUTPUT_VIRTUAL_PATH = "/output/";
+const AGENTS_MEMORY_VIRTUAL_PATHS = [
+    "/AGENTS.md"
+];
 const DEFAULT_DEEPAGENT_MODEL = "claude-sonnet-4-5-20250929";
 const isPathWithinRoot = (targetPath, rootPath)=>{
     const normalizedTarget = (0, external_node_path_namespaceObject.normalize)(targetPath);
@@ -81,6 +87,11 @@ const resolveExecutionWorkspace = (workspace, workdir)=>{
     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 resolveAgentExecutionWorkspace = (workspace, workdir, defaultOutputDir)=>{
+    const preferredWorkdir = workdir || defaultOutputDir || null;
+    return resolveExecutionWorkspace(workspace, preferredWorkdir);
+};
+const resolveAgentMemorySources = (executionWorkspace)=>AGENTS_MEMORY_VIRTUAL_PATHS.filter((memoryPath)=>(0, external_node_fs_namespaceObject.existsSync)((0, external_node_path_namespaceObject.join)(executionWorkspace, memoryPath.replace(/^\/+/, ""))));
 const toWorkspaceAliasVirtualPath = (absolutePath)=>{
     const normalized = (0, external_node_path_namespaceObject.normalize)(absolutePath);
     if (!(0, external_node_path_namespaceObject.isAbsolute)(normalized)) return null;
@@ -284,24 +295,19 @@ const trackRootLangGraphRunId = (currentRootLangGraphRunId, chunk)=>{
     return extractEventRunId(eventRecord) || currentRootLangGraphRunId;
 };
 const isRootLangGraphTerminalEvent = (chunk, rootLangGraphRunId)=>{
-    if (!rootLangGraphRunId) return false;
     const eventRecord = extractStreamEventRecord(chunk);
     if (!eventRecord || !isRootLangGraphChainEvent(eventRecord, "on_chain_end")) return false;
+    if (!rootLangGraphRunId) return true;
     const chunkRunId = extractEventRunId(eventRecord);
+    if (!chunkRunId) return true;
     return Boolean(chunkRunId && chunkRunId === rootLangGraphRunId);
 };
-const evaluateStreamingCompletion = (input)=>{
-    if (!input.sawAssistantText && !input.fallbackText) {
-        const message = input.streamErrorMessage ? `Model call failed: ${input.streamErrorMessage}` : "Model completed without a response. Check provider logs for request errors.";
-        return {
-            status: "blocked",
-            reason: input.streamErrorMessage ? "stream_error" : "empty_stream_response",
-            message
-        };
-    }
-    return {
-        status: "ok"
-    };
+const emitCompletionAndContinuePostProcessing = (input)=>{
+    input.outputManager.emitAgentComplete(input.result);
+    if (!input.postProcess) return;
+    input.postProcess().catch((error)=>{
+        input.logger?.debug("Failed post-completion processing for streamed agent response", error);
+    });
 };
 class AgentInvoker {
     findAllAgents() {
@@ -315,14 +321,11 @@ class AgentInvoker {
         let cancellationHandled = false;
         let activeToolName = null;
         let lastToolName = null;
-        let sawAssistantText = false;
-        let streamErrorMessage;
         let rootLangGraphRunId;
-        let preInvocationMessages = null;
         const isCancelled = ()=>options?.signal?.aborted === true;
         try {
             const hookSessionId = sessionId || (0, external_uuid_namespaceObject.v4)();
-            const executionWorkspace = resolveExecutionWorkspace(this.workspace, this.workdir);
+            const executionWorkspace = resolveAgentExecutionWorkspace(this.workspace, this.workdir, this.defaultOutputDir);
             const effectiveWorkdir = this.workdir ? executionWorkspace : null;
             const loader = new agentLoader_cjs_namespaceObject.AgentLoader(this.configDir, this.workspace, this.wingmanConfig, executionWorkspace, {
                 terminalOwnerId: `${agentName}:${hookSessionId}`,
@@ -341,7 +344,9 @@ class AgentInvoker {
             if (targetAgent.mcpUseGlobal && this.wingmanConfig.mcp) mcpConfigs.push(this.wingmanConfig.mcp);
             if (mcpConfigs.length > 0) {
                 this.logger.debug("Initializing MCP client for agent invocation");
-                this.mcpManager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(mcpConfigs, this.logger);
+                this.mcpManager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(mcpConfigs, this.logger, {
+                    executionWorkspace
+                });
                 await this.mcpManager.initialize();
                 const mcpTools = await this.mcpManager.getTools();
                 if (mcpTools.length > 0) {
@@ -358,6 +363,7 @@ class AgentInvoker {
             const normalizedSkillsDirectory = skillsDirectory.replace(/^\/+|\/+$/g, "");
             const skillsVirtualPath = `/${normalizedSkillsDirectory}/`;
             const outputMount = resolveExternalOutputMount(executionWorkspace, effectiveWorkdir, this.defaultOutputDir);
+            const memorySources = resolveAgentMemorySources(executionWorkspace);
             const middleware = [
                 (0, media_compat_cjs_namespaceObject.mediaCompatibilityMiddleware)({
                     model: targetAgent.model
@@ -442,6 +448,7 @@ class AgentInvoker {
                 middleware: middleware,
                 interruptOn: hitlSettings?.interruptOn,
                 skills: skillsSources,
+                memory: memorySources,
                 subagents: targetAgent.subagents || [],
                 checkpointer: checkpointer
             });
@@ -450,15 +457,6 @@ class AgentInvoker {
             const userContent = buildUserContent(prompt, attachments, targetAgent.model);
             if (this.sessionManager && sessionId) {
                 this.logger.debug(`Using streaming with session: ${sessionId}`);
-                try {
-                    const messages = await this.sessionManager.listMessages(sessionId);
-                    preInvocationMessages = messages.map((message)=>({
-                            role: message.role,
-                            content: message.content
-                        }));
-                } catch (stateError) {
-                    this.logger.debug("Failed to capture pre-invocation session state", stateError);
-                }
                 const stream = await standaloneAgent.streamEvents({
                     messages: [
                         {
@@ -476,8 +474,6 @@ class AgentInvoker {
                 });
                 for await (const chunk of stream){
                     rootLangGraphRunId = trackRootLangGraphRunId(rootLangGraphRunId, chunk);
-                    if (!sawAssistantText && chunkHasAssistantText(chunk)) sawAssistantText = true;
-                    if (!streamErrorMessage) streamErrorMessage = detectStreamErrorMessage(chunk);
                     const toolEvent = detectToolEventContext(chunk);
                     if (toolEvent) {
                         lastToolName = toolEvent.toolName;
@@ -507,37 +503,15 @@ class AgentInvoker {
                         cancelled: true
                     };
                 }
-                let fallbackText;
-                if (!sawAssistantText && this.sessionManager && sessionId && preInvocationMessages) try {
-                    const sessionMessages = await this.sessionManager.listMessages(sessionId);
-                    fallbackText = selectStreamingFallbackText(preInvocationMessages, sessionMessages.map((message)=>({
-                            role: message.role,
-                            content: message.content
-                        })));
-                } catch (stateError) {
-                    this.logger.debug("Failed to derive streaming fallback text from session state", stateError);
-                }
-                const completionOutcome = evaluateStreamingCompletion({
-                    sawAssistantText,
-                    fallbackText,
-                    streamErrorMessage
-                });
-                if ("blocked" === completionOutcome.status) {
-                    this.logger.warn(completionOutcome.message);
-                    this.outputManager.emitAgentError(completionOutcome.message);
-                    return {
-                        blocked: true,
-                        reason: completionOutcome.reason
-                    };
-                }
-                this.logger.info("Agent streaming completed successfully", {
-                    usedFallbackText: Boolean(fallbackText)
-                });
-                this.outputManager.emitAgentComplete({
-                    streaming: true,
-                    ...fallbackText ? {
-                        fallbackText
-                    } : {}
+                this.logger.info("Agent streaming completed successfully");
+                const completionPayload = {
+                    streaming: true
+                };
+                emitCompletionAndContinuePostProcessing({
+                    outputManager: this.outputManager,
+                    result: completionPayload,
+                    postProcess: ()=>this.materializeSessionImages(sessionId),
+                    logger: this.logger
                 });
                 return {
                     streaming: true
@@ -573,7 +547,12 @@ class AgentInvoker {
                     };
                 }
                 this.logger.info("Agent completed successfully");
-                this.outputManager.emitAgentComplete(result);
+                emitCompletionAndContinuePostProcessing({
+                    outputManager: this.outputManager,
+                    result,
+                    postProcess: ()=>this.materializeSessionImages(sessionId),
+                    logger: this.logger
+                });
                 return result;
             }
         } catch (error) {
@@ -605,6 +584,10 @@ class AgentInvoker {
                 description: a.description
             }));
     }
+    async materializeSessionImages(sessionId) {
+        if (!this.sessionManager || !sessionId) return;
+        await this.sessionManager.listMessages(sessionId);
+    }
     constructor(options){
         _define_property(this, "loader", void 0);
         _define_property(this, "outputManager", void 0);
@@ -815,6 +798,7 @@ function buildAttachmentPreview(attachments) {
     if (hasImage) return "[image]";
     return "";
 }
+exports.AGENTS_MEMORY_VIRTUAL_PATHS = __webpack_exports__.AGENTS_MEMORY_VIRTUAL_PATHS;
 exports.AgentInvoker = __webpack_exports__.AgentInvoker;
 exports.OUTPUT_VIRTUAL_PATH = __webpack_exports__.OUTPUT_VIRTUAL_PATH;
 exports.WORKDIR_VIRTUAL_PATH = __webpack_exports__.WORKDIR_VIRTUAL_PATH;
@@ -823,8 +807,10 @@ exports.chunkHasAssistantText = __webpack_exports__.chunkHasAssistantText;
 exports.configureDeepAgentSummarizationMiddleware = __webpack_exports__.configureDeepAgentSummarizationMiddleware;
 exports.detectStreamErrorMessage = __webpack_exports__.detectStreamErrorMessage;
 exports.detectToolEventContext = __webpack_exports__.detectToolEventContext;
-exports.evaluateStreamingCompletion = __webpack_exports__.evaluateStreamingCompletion;
+exports.emitCompletionAndContinuePostProcessing = __webpack_exports__.emitCompletionAndContinuePostProcessing;
 exports.isRootLangGraphTerminalEvent = __webpack_exports__.isRootLangGraphTerminalEvent;
+exports.resolveAgentExecutionWorkspace = __webpack_exports__.resolveAgentExecutionWorkspace;
+exports.resolveAgentMemorySources = __webpack_exports__.resolveAgentMemorySources;
 exports.resolveExecutionWorkspace = __webpack_exports__.resolveExecutionWorkspace;
 exports.resolveExternalOutputMount = __webpack_exports__.resolveExternalOutputMount;
 exports.resolveHumanInTheLoopSettings = __webpack_exports__.resolveHumanInTheLoopSettings;
@@ -835,6 +821,7 @@ exports.selectStreamingFallbackText = __webpack_exports__.selectStreamingFallbac
 exports.toWorkspaceAliasVirtualPath = __webpack_exports__.toWorkspaceAliasVirtualPath;
 exports.trackRootLangGraphRunId = __webpack_exports__.trackRootLangGraphRunId;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AGENTS_MEMORY_VIRTUAL_PATHS",
     "AgentInvoker",
     "OUTPUT_VIRTUAL_PATH",
     "WORKDIR_VIRTUAL_PATH",
@@ -843,8 +830,10 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "configureDeepAgentSummarizationMiddleware",
     "detectStreamErrorMessage",
     "detectToolEventContext",
-    "evaluateStreamingCompletion",
+    "emitCompletionAndContinuePostProcessing",
     "isRootLangGraphTerminalEvent",
+    "resolveAgentExecutionWorkspace",
+    "resolveAgentMemorySources",
     "resolveExecutionWorkspace",
     "resolveExternalOutputMount",
     "resolveHumanInTheLoopSettings",

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

@@ -78,6 +78,7 @@ type UserContentPart = {
 };
 export declare const WORKDIR_VIRTUAL_PATH = "/workdir/";
 export declare const OUTPUT_VIRTUAL_PATH = "/output/";
+export declare const AGENTS_MEMORY_VIRTUAL_PATHS: readonly ["/AGENTS.md"];
 export type ExternalOutputMount = {
     virtualPath: string | null;
     absolutePath: string | null;
@@ -105,6 +106,8 @@ export type HumanInTheLoopSettings = {
     }>;
 };
 export declare const resolveExecutionWorkspace: (workspace: string, workdir?: string | null) => string;
+export declare const resolveAgentExecutionWorkspace: (workspace: string, workdir?: string | null, defaultOutputDir?: string | null) => string;
+export declare const resolveAgentMemorySources: (executionWorkspace: string) => string[];
 export declare const toWorkspaceAliasVirtualPath: (absolutePath: string) => string | null;
 export declare const resolveExternalOutputMount: (workspace: string, workdir?: string | null, defaultOutputDir?: string | null) => ExternalOutputMount;
 export declare const resolveSummarizationMiddlewareSettings: (config: WingmanConfigType) => SummarizationMiddlewareSettings | null;
@@ -128,19 +131,12 @@ export declare const selectStreamingFallbackText: (previousMessages: Array<{
 export declare const detectStreamErrorMessage: (chunk: unknown) => string | undefined;
 export declare const trackRootLangGraphRunId: (currentRootLangGraphRunId: string | undefined, chunk: unknown) => string | undefined;
 export declare const isRootLangGraphTerminalEvent: (chunk: unknown, rootLangGraphRunId?: string) => boolean;
-type StreamingCompletionOutcome = {
-    status: "blocked";
-    reason: "stream_error" | "empty_stream_response";
-    message: string;
-} | {
-    status: "ok";
-};
-type EvaluateStreamingCompletionInput = {
-    sawAssistantText: boolean;
-    fallbackText?: string;
-    streamErrorMessage?: string;
-};
-export declare const evaluateStreamingCompletion: (input: EvaluateStreamingCompletionInput) => StreamingCompletionOutcome;
+export declare const emitCompletionAndContinuePostProcessing: (input: {
+    outputManager: Pick<OutputManager, "emitAgentComplete">;
+    result: unknown;
+    postProcess?: () => Promise<void>;
+    logger?: Pick<Logger, "debug">;
+}) => void;
 export declare class AgentInvoker {
     private loader;
     private outputManager;
@@ -170,6 +166,7 @@ export declare class AgentInvoker {
         name: string;
         description: string;
     }>;
+    private materializeSessionImages;
 }
 export declare function buildUserContent(prompt: string, attachments?: MediaAttachment[], model?: unknown): string | UserContentPart[];
 export {};