@wingman-ai/gateway 0.2.5 → 0.3.0

package/dist/cli/core/agentInvoker.js

@@ -24,6 +24,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 = normalize(targetPath);
@@ -35,6 +38,11 @@ const resolveExecutionWorkspace = (workspace, workdir)=>{
     if (isAbsolute(workdir)) return normalize(workdir);
     return normalize(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)=>existsSync(join(executionWorkspace, memoryPath.replace(/^\/+/, ""))));
 const toWorkspaceAliasVirtualPath = (absolutePath)=>{
     const normalized = normalize(absolutePath);
     if (!isAbsolute(normalized)) return null;
@@ -238,24 +246,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() {
@@ -269,14 +272,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 || 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(this.configDir, this.workspace, this.wingmanConfig, executionWorkspace, {
                 terminalOwnerId: `${agentName}:${hookSessionId}`,
@@ -295,7 +295,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(mcpConfigs, this.logger);
+                this.mcpManager = new MCPClientManager(mcpConfigs, this.logger, {
+                    executionWorkspace
+                });
                 await this.mcpManager.initialize();
                 const mcpTools = await this.mcpManager.getTools();
                 if (mcpTools.length > 0) {
@@ -312,6 +314,7 @@ class AgentInvoker {
             const normalizedSkillsDirectory = skillsDirectory.replace(/^\/+|\/+$/g, "");
             const skillsVirtualPath = `/${normalizedSkillsDirectory}/`;
             const outputMount = resolveExternalOutputMount(executionWorkspace, effectiveWorkdir, this.defaultOutputDir);
+            const memorySources = resolveAgentMemorySources(executionWorkspace);
             const middleware = [
                 mediaCompatibilityMiddleware({
                     model: targetAgent.model
@@ -396,6 +399,7 @@ class AgentInvoker {
                 middleware: middleware,
                 interruptOn: hitlSettings?.interruptOn,
                 skills: skillsSources,
+                memory: memorySources,
                 subagents: targetAgent.subagents || [],
                 checkpointer: checkpointer
             });
@@ -404,15 +408,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: [
                         {
@@ -430,8 +425,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;
@@ -461,37 +454,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
@@ -527,7 +498,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) {
@@ -559,6 +535,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);
@@ -769,4 +749,4 @@ function buildAttachmentPreview(attachments) {
     if (hasImage) return "[image]";
     return "";
 }
-export { AgentInvoker, OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, buildUserContent, chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectStreamErrorMessage, detectToolEventContext, evaluateStreamingCompletion, isRootLangGraphTerminalEvent, resolveExecutionWorkspace, resolveExternalOutputMount, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, toWorkspaceAliasVirtualPath, trackRootLangGraphRunId };
+export { AGENTS_MEMORY_VIRTUAL_PATHS, AgentInvoker, OUTPUT_VIRTUAL_PATH, WORKDIR_VIRTUAL_PATH, buildUserContent, chunkHasAssistantText, configureDeepAgentSummarizationMiddleware, detectStreamErrorMessage, detectToolEventContext, emitCompletionAndContinuePostProcessing, isRootLangGraphTerminalEvent, resolveAgentExecutionWorkspace, resolveAgentMemorySources, resolveExecutionWorkspace, resolveExternalOutputMount, resolveHumanInTheLoopSettings, resolveModelRetryMiddlewareSettings, resolveSummarizationMiddlewareSettings, resolveToolRetryMiddlewareSettings, selectStreamingFallbackText, toWorkspaceAliasVirtualPath, trackRootLangGraphRunId };

package/dist/cli/core/imagePersistence.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    persistAssistantImagesToDisk: ()=>persistAssistantImagesToDisk,
+    parseBase64DataUrl: ()=>parseBase64DataUrl,
+    resolveImageExtension: ()=>resolveImageExtension
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const DATA_URL_BASE64_PATTERN = /^data:([^;,]+);base64,(.+)$/i;
+function persistAssistantImagesToDisk(input) {
+    if (!input.messages.length) return;
+    const mediaRoot = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(input.dbPath), "media", sanitizePathSegment(input.sessionId));
+    for (const message of input.messages)if ("assistant" === message.role) {
+        if (Array.isArray(message.attachments) && 0 !== message.attachments.length) for (const attachment of message.attachments){
+            if (!attachment || "image" !== attachment.kind) continue;
+            if (attachment.path) continue;
+            const parsed = parseBase64DataUrl(attachment.dataUrl);
+            if (!parsed) continue;
+            if (!parsed.mimeType.toLowerCase().startsWith("image/")) continue;
+            let bytes;
+            try {
+                bytes = Buffer.from(parsed.data, "base64");
+            } catch  {
+                continue;
+            }
+            if (0 === bytes.length) continue;
+            const extension = resolveImageExtension(parsed.mimeType);
+            const hash = (0, external_node_crypto_namespaceObject.createHash)("sha256").update(bytes).digest("hex").slice(0, 20);
+            const filename = `${hash}.${extension}`;
+            const outputPath = (0, external_node_path_namespaceObject.join)(mediaRoot, filename);
+            if (!(0, external_node_fs_namespaceObject.existsSync)(outputPath)) {
+                (0, external_node_fs_namespaceObject.mkdirSync)(mediaRoot, {
+                    recursive: true
+                });
+                (0, external_node_fs_namespaceObject.writeFileSync)(outputPath, bytes);
+            }
+            attachment.path = outputPath;
+            if (!attachment.mimeType) attachment.mimeType = parsed.mimeType;
+            if ("number" != typeof attachment.size || attachment.size <= 0) attachment.size = bytes.length;
+            if (!attachment.name) attachment.name = `image-${hash.slice(0, 8)}.${extension}`;
+        }
+    }
+}
+function parseBase64DataUrl(dataUrl) {
+    if ("string" != typeof dataUrl) return null;
+    const match = dataUrl.match(DATA_URL_BASE64_PATTERN);
+    if (!match) return null;
+    return {
+        mimeType: match[1].trim().toLowerCase(),
+        data: match[2].trim()
+    };
+}
+function resolveImageExtension(mimeType) {
+    const normalized = (mimeType || "").trim().toLowerCase();
+    switch(normalized){
+        case "image/jpeg":
+            return "jpg";
+        case "image/png":
+            return "png";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        case "image/svg+xml":
+            return "svg";
+        case "image/bmp":
+            return "bmp";
+        case "image/tiff":
+            return "tiff";
+        case "image/heic":
+            return "heic";
+        case "image/heif":
+            return "heif";
+        case "image/avif":
+            return "avif";
+        default:
+            {
+                const subtype = normalized.split("/")[1] || "";
+                const sanitized = subtype.replace(/[^a-z0-9]/g, "");
+                return sanitized || "img";
+            }
+    }
+}
+function sanitizePathSegment(value) {
+    const normalized = (value || "").trim();
+    if (!normalized) return "default-session";
+    const sanitized = normalized.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return sanitized.slice(0, 120) || "default-session";
+}
+exports.parseBase64DataUrl = __webpack_exports__.parseBase64DataUrl;
+exports.persistAssistantImagesToDisk = __webpack_exports__.persistAssistantImagesToDisk;
+exports.resolveImageExtension = __webpack_exports__.resolveImageExtension;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseBase64DataUrl",
+    "persistAssistantImagesToDisk",
+    "resolveImageExtension"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,24 @@
+export interface PersistableAttachment {
+    kind: "image" | "audio" | "file";
+    dataUrl: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+    path?: string;
+}
+export interface PersistableMessage {
+    role: "user" | "assistant";
+    attachments?: PersistableAttachment[];
+}
+type ParsedDataUrl = {
+    mimeType: string;
+    data: string;
+};
+export declare function persistAssistantImagesToDisk(input: {
+    dbPath: string;
+    sessionId: string;
+    messages: PersistableMessage[];
+}): void;
+export declare function parseBase64DataUrl(dataUrl: string): ParsedDataUrl | null;
+export declare function resolveImageExtension(mimeType: string): string;
+export {};

package/dist/cli/core/imagePersistence.js

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+const DATA_URL_BASE64_PATTERN = /^data:([^;,]+);base64,(.+)$/i;
+function persistAssistantImagesToDisk(input) {
+    if (!input.messages.length) return;
+    const mediaRoot = join(dirname(input.dbPath), "media", sanitizePathSegment(input.sessionId));
+    for (const message of input.messages)if ("assistant" === message.role) {
+        if (Array.isArray(message.attachments) && 0 !== message.attachments.length) for (const attachment of message.attachments){
+            if (!attachment || "image" !== attachment.kind) continue;
+            if (attachment.path) continue;
+            const parsed = parseBase64DataUrl(attachment.dataUrl);
+            if (!parsed) continue;
+            if (!parsed.mimeType.toLowerCase().startsWith("image/")) continue;
+            let bytes;
+            try {
+                bytes = Buffer.from(parsed.data, "base64");
+            } catch  {
+                continue;
+            }
+            if (0 === bytes.length) continue;
+            const extension = resolveImageExtension(parsed.mimeType);
+            const hash = createHash("sha256").update(bytes).digest("hex").slice(0, 20);
+            const filename = `${hash}.${extension}`;
+            const outputPath = join(mediaRoot, filename);
+            if (!existsSync(outputPath)) {
+                mkdirSync(mediaRoot, {
+                    recursive: true
+                });
+                writeFileSync(outputPath, bytes);
+            }
+            attachment.path = outputPath;
+            if (!attachment.mimeType) attachment.mimeType = parsed.mimeType;
+            if ("number" != typeof attachment.size || attachment.size <= 0) attachment.size = bytes.length;
+            if (!attachment.name) attachment.name = `image-${hash.slice(0, 8)}.${extension}`;
+        }
+    }
+}
+function parseBase64DataUrl(dataUrl) {
+    if ("string" != typeof dataUrl) return null;
+    const match = dataUrl.match(DATA_URL_BASE64_PATTERN);
+    if (!match) return null;
+    return {
+        mimeType: match[1].trim().toLowerCase(),
+        data: match[2].trim()
+    };
+}
+function resolveImageExtension(mimeType) {
+    const normalized = (mimeType || "").trim().toLowerCase();
+    switch(normalized){
+        case "image/jpeg":
+            return "jpg";
+        case "image/png":
+            return "png";
+        case "image/webp":
+            return "webp";
+        case "image/gif":
+            return "gif";
+        case "image/svg+xml":
+            return "svg";
+        case "image/bmp":
+            return "bmp";
+        case "image/tiff":
+            return "tiff";
+        case "image/heic":
+            return "heic";
+        case "image/heif":
+            return "heif";
+        case "image/avif":
+            return "avif";
+        default:
+            {
+                const subtype = normalized.split("/")[1] || "";
+                const sanitized = subtype.replace(/[^a-z0-9]/g, "");
+                return sanitized || "img";
+            }
+    }
+}
+function sanitizePathSegment(value) {
+    const normalized = (value || "").trim();
+    if (!normalized) return "default-session";
+    const sanitized = normalized.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return sanitized.slice(0, 120) || "default-session";
+}
+export { parseBase64DataUrl, persistAssistantImagesToDisk, resolveImageExtension };