@wingman-ai/gateway 0.1.0

package/dist/cli/core/agentInvoker.cjs

@@ -0,0 +1,284 @@
+"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__, {
+    buildUserContent: ()=>buildUserContent,
+    AgentInvoker: ()=>AgentInvoker
+});
+const external_deepagents_namespaceObject = require("deepagents");
+const external_node_path_namespaceObject = require("node:path");
+const external_uuid_namespaceObject = require("uuid");
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const loader_cjs_namespaceObject = require("../config/loader.cjs");
+const additional_messages_cjs_namespaceObject = require("../../agent/middleware/additional-messages.cjs");
+const hooks_cjs_namespaceObject = require("../../agent/middleware/hooks.cjs");
+const merger_cjs_namespaceObject = require("../../agent/middleware/hooks/merger.cjs");
+const media_compat_cjs_namespaceObject = require("../../agent/middleware/media-compat.cjs");
+const mcpClientManager_cjs_namespaceObject = require("../../agent/config/mcpClientManager.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class AgentInvoker {
+    findAllAgents() {
+        const agentConfigs = this.loader.loadAllAgentConfigs();
+        return agentConfigs;
+    }
+    async findAgent(name) {
+        return await this.loader.loadAgent(name);
+    }
+    async invokeAgent(agentName, prompt, sessionId, attachments) {
+        try {
+            const targetAgent = await this.findAgent(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) : "");
+            this.outputManager.emitAgentStart(agentName, preview);
+            this.logger.debug(`Found ${this.wingmanConfig.toolHooks ? "global hooks" : "no global hooks"}`);
+            this.logger.debug(`Found ${targetAgent.toolHooks ? "agent-specific hooks" : "no agent-specific hooks"}`);
+            const mergedHooks = (0, merger_cjs_namespaceObject.mergeHooks)(this.wingmanConfig.toolHooks, targetAgent.toolHooks);
+            const hookSessionId = sessionId || (0, external_uuid_namespaceObject.v4)();
+            const mcpConfigs = [];
+            if (targetAgent.mcpConfig) mcpConfigs.push(targetAgent.mcpConfig);
+            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);
+                await this.mcpManager.initialize();
+                const mcpTools = await this.mcpManager.getTools();
+                if (mcpTools.length > 0) {
+                    const existing = new Set((targetAgent.tools || []).map((tool)=>tool.name));
+                    const unique = mcpTools.filter((tool)=>!existing.has(tool.name));
+                    targetAgent.tools = [
+                        ...targetAgent.tools || [],
+                        ...unique
+                    ];
+                    this.logger.info(`Added ${unique.length} MCP tools to agent`);
+                }
+            }
+            const middleware = [
+                (0, media_compat_cjs_namespaceObject.mediaCompatibilityMiddleware)({
+                    model: targetAgent.model
+                }),
+                (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)({
+                    workdir: this.workdir,
+                    defaultOutputDir: this.defaultOutputDir
+                })
+            ];
+            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));
+            }
+            const checkpointer = this.sessionManager?.getCheckpointer();
+            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,
+                        virtualMode: true
+                    }), {
+                        "/memories/": new external_deepagents_namespaceObject.FilesystemBackend({
+                            rootDir: (0, external_node_path_namespaceObject.join)(this.workspace, this.configDir, "memories"),
+                            virtualMode: true
+                        })
+                    }),
+                middleware,
+                skills: [
+                    "/skills/"
+                ],
+                subagents: [
+                    ...targetAgent.subagents || []
+                ],
+                checkpointer: checkpointer
+            });
+            this.logger.debug("Agent created, sending message");
+            const userContent = buildUserContent(prompt, attachments);
+            if (this.sessionManager && sessionId) {
+                this.logger.debug(`Using streaming with session: ${sessionId}`);
+                const stream = await standaloneAgent.streamEvents({
+                    messages: [
+                        {
+                            role: "user",
+                            content: userContent
+                        }
+                    ]
+                }, {
+                    recursionLimit: this.wingmanConfig.recursionLimit,
+                    configurable: {
+                        thread_id: sessionId
+                    },
+                    version: "v2"
+                });
+                for await (const chunk of stream)this.outputManager.emitAgentStream(chunk);
+                this.logger.info("Agent streaming completed successfully");
+                this.outputManager.emitAgentComplete({
+                    streaming: true
+                });
+                return {
+                    streaming: true
+                };
+            }
+            {
+                this.logger.debug("Using blocking invoke (no session manager)");
+                const result = await standaloneAgent.invoke({
+                    messages: [
+                        {
+                            role: "user",
+                            content: userContent
+                        }
+                    ]
+                }, {
+                    recursionLimit: this.wingmanConfig.recursionLimit
+                });
+                this.logger.info("Agent completed successfully");
+                this.outputManager.emitAgentComplete(result);
+                return result;
+            }
+        } catch (error) {
+            this.logger.error(`Agent invocation failed: ${error instanceof Error ? error.message : String(error)}`);
+            this.outputManager.emitAgentError(error);
+            throw error;
+        } finally{
+            if (this.mcpManager) {
+                this.logger.debug("Cleaning up MCP client");
+                await this.mcpManager.cleanup();
+                this.mcpManager = null;
+            }
+        }
+    }
+    listAgents() {
+        const agents = this.findAllAgents();
+        return agents.map((a)=>({
+                name: a.name,
+                description: a.description
+            }));
+    }
+    constructor(options){
+        _define_property(this, "loader", void 0);
+        _define_property(this, "outputManager", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "wingmanConfig", void 0);
+        _define_property(this, "mcpManager", null);
+        _define_property(this, "sessionManager", null);
+        _define_property(this, "workdir", null);
+        _define_property(this, "defaultOutputDir", null);
+        this.outputManager = options.outputManager;
+        this.logger = options.logger;
+        this.workspace = options.workspace || process.cwd();
+        this.configDir = options.configDir || ".wingman";
+        this.sessionManager = options.sessionManager || null;
+        this.workdir = options.workdir || null;
+        this.defaultOutputDir = options.defaultOutputDir || null;
+        const configLoader = new loader_cjs_namespaceObject.WingmanConfigLoader(this.configDir, this.workspace);
+        this.wingmanConfig = configLoader.loadConfig();
+        this.loader = new agentLoader_cjs_namespaceObject.AgentLoader(this.configDir, this.workspace, this.wingmanConfig);
+    }
+}
+function buildUserContent(prompt, attachments) {
+    const text = prompt?.trim() ?? "";
+    if (!attachments || 0 === attachments.length) return text;
+    const parts = [];
+    if (text) parts.push({
+        type: "text",
+        text
+    });
+    for (const attachment of attachments)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.");
+        return text;
+    }
+    return parts;
+}
+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 buildAudioPart(attachment) {
+    const parsed = parseDataUrl(attachment.dataUrl);
+    const mimeType = attachment.mimeType || parsed.mimeType;
+    if (parsed.data) return {
+        type: "audio",
+        source_type: "base64",
+        data: parsed.data,
+        mime_type: mimeType
+    };
+    return {
+        type: "audio",
+        source_type: "url",
+        url: attachment.dataUrl,
+        mime_type: mimeType
+    };
+}
+function parseDataUrl(dataUrl) {
+    if (!dataUrl.startsWith("data:")) return {};
+    const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
+    if (!match) return {};
+    return {
+        mimeType: match[1],
+        data: match[2]
+    };
+}
+function buildAttachmentPreview(attachments) {
+    let hasAudio = false;
+    let hasImage = false;
+    for (const attachment of attachments)if (isAudioAttachment(attachment)) hasAudio = true;
+    else hasImage = true;
+    if (hasAudio && hasImage) return "[attachments]";
+    if (hasAudio) return "[audio]";
+    if (hasImage) return "[image]";
+    return "";
+}
+exports.AgentInvoker = __webpack_exports__.AgentInvoker;
+exports.buildUserContent = __webpack_exports__.buildUserContent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentInvoker",
+    "buildUserContent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,77 @@
+import type { OutputManager } from "./outputManager.js";
+import type { Logger } from "../../logger.js";
+import type { WingmanAgentConfig } from "@/agent/config/agentConfig.js";
+import type { WingmanAgent } from "@/types/agents.js";
+import { SessionManager } from "./sessionManager.js";
+export interface AgentInvokerOptions {
+    workspace?: string;
+    configDir?: string;
+    outputManager: OutputManager;
+    logger: Logger;
+    sessionManager?: SessionManager;
+    workdir?: string | null;
+    defaultOutputDir?: string | null;
+}
+export type ImageAttachment = {
+    kind?: "image";
+    dataUrl: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+};
+export type AudioAttachment = {
+    kind: "audio";
+    dataUrl: string;
+    mimeType?: string;
+    name?: string;
+    size?: number;
+};
+export type MediaAttachment = ImageAttachment | AudioAttachment;
+export declare class AgentInvoker {
+    private loader;
+    private outputManager;
+    private logger;
+    private workspace;
+    private configDir;
+    private wingmanConfig;
+    private mcpManager;
+    private sessionManager;
+    private workdir;
+    private defaultOutputDir;
+    constructor(options: AgentInvokerOptions);
+    findAllAgents(): WingmanAgentConfig[];
+    /**
+     * Find an agent by name
+     */
+    findAgent(name: string): Promise<WingmanAgent | undefined>;
+    /**
+     * Invoke a specific agent directly (bypassing main orchestration)
+     */
+    invokeAgent(agentName: string, prompt: string, sessionId?: string, attachments?: MediaAttachment[]): Promise<any>;
+    /**
+     * List all available agents with their descriptions
+     */
+    listAgents(): Array<{
+        name: string;
+        description: string;
+    }>;
+}
+export declare function buildUserContent(prompt: string, attachments?: MediaAttachment[]): string | Array<{
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+} | {
+    type: "audio";
+    source_type: "base64";
+    data: string;
+    mime_type?: string;
+} | {
+    type: "audio";
+    source_type: "url";
+    url: string;
+    mime_type?: string;
+}>;

package/dist/cli/core/agentInvoker.js

@@ -0,0 +1,247 @@
+import { CompositeBackend, FilesystemBackend, createDeepAgent } from "deepagents";
+import { join } from "node:path";
+import { v4 } from "uuid";
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+import { WingmanConfigLoader } from "../config/loader.js";
+import { additionalMessageMiddleware } from "../../agent/middleware/additional-messages.js";
+import { createHooksMiddleware } from "../../agent/middleware/hooks.js";
+import { mergeHooks } from "../../agent/middleware/hooks/merger.js";
+import { mediaCompatibilityMiddleware } from "../../agent/middleware/media-compat.js";
+import { MCPClientManager } from "../../agent/config/mcpClientManager.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class AgentInvoker {
+    findAllAgents() {
+        const agentConfigs = this.loader.loadAllAgentConfigs();
+        return agentConfigs;
+    }
+    async findAgent(name) {
+        return await this.loader.loadAgent(name);
+    }
+    async invokeAgent(agentName, prompt, sessionId, attachments) {
+        try {
+            const targetAgent = await this.findAgent(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) : "");
+            this.outputManager.emitAgentStart(agentName, preview);
+            this.logger.debug(`Found ${this.wingmanConfig.toolHooks ? "global hooks" : "no global hooks"}`);
+            this.logger.debug(`Found ${targetAgent.toolHooks ? "agent-specific hooks" : "no agent-specific hooks"}`);
+            const mergedHooks = mergeHooks(this.wingmanConfig.toolHooks, targetAgent.toolHooks);
+            const hookSessionId = sessionId || v4();
+            const mcpConfigs = [];
+            if (targetAgent.mcpConfig) mcpConfigs.push(targetAgent.mcpConfig);
+            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);
+                await this.mcpManager.initialize();
+                const mcpTools = await this.mcpManager.getTools();
+                if (mcpTools.length > 0) {
+                    const existing = new Set((targetAgent.tools || []).map((tool)=>tool.name));
+                    const unique = mcpTools.filter((tool)=>!existing.has(tool.name));
+                    targetAgent.tools = [
+                        ...targetAgent.tools || [],
+                        ...unique
+                    ];
+                    this.logger.info(`Added ${unique.length} MCP tools to agent`);
+                }
+            }
+            const middleware = [
+                mediaCompatibilityMiddleware({
+                    model: targetAgent.model
+                }),
+                additionalMessageMiddleware({
+                    workdir: this.workdir,
+                    defaultOutputDir: this.defaultOutputDir
+                })
+            ];
+            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));
+            }
+            const checkpointer = this.sessionManager?.getCheckpointer();
+            const standaloneAgent = createDeepAgent({
+                systemPrompt: targetAgent.systemPrompt,
+                tools: targetAgent.tools,
+                model: targetAgent.model,
+                backend: ()=>new CompositeBackend(new FilesystemBackend({
+                        rootDir: this.workspace,
+                        virtualMode: true
+                    }), {
+                        "/memories/": new FilesystemBackend({
+                            rootDir: join(this.workspace, this.configDir, "memories"),
+                            virtualMode: true
+                        })
+                    }),
+                middleware,
+                skills: [
+                    "/skills/"
+                ],
+                subagents: [
+                    ...targetAgent.subagents || []
+                ],
+                checkpointer: checkpointer
+            });
+            this.logger.debug("Agent created, sending message");
+            const userContent = buildUserContent(prompt, attachments);
+            if (this.sessionManager && sessionId) {
+                this.logger.debug(`Using streaming with session: ${sessionId}`);
+                const stream = await standaloneAgent.streamEvents({
+                    messages: [
+                        {
+                            role: "user",
+                            content: userContent
+                        }
+                    ]
+                }, {
+                    recursionLimit: this.wingmanConfig.recursionLimit,
+                    configurable: {
+                        thread_id: sessionId
+                    },
+                    version: "v2"
+                });
+                for await (const chunk of stream)this.outputManager.emitAgentStream(chunk);
+                this.logger.info("Agent streaming completed successfully");
+                this.outputManager.emitAgentComplete({
+                    streaming: true
+                });
+                return {
+                    streaming: true
+                };
+            }
+            {
+                this.logger.debug("Using blocking invoke (no session manager)");
+                const result = await standaloneAgent.invoke({
+                    messages: [
+                        {
+                            role: "user",
+                            content: userContent
+                        }
+                    ]
+                }, {
+                    recursionLimit: this.wingmanConfig.recursionLimit
+                });
+                this.logger.info("Agent completed successfully");
+                this.outputManager.emitAgentComplete(result);
+                return result;
+            }
+        } catch (error) {
+            this.logger.error(`Agent invocation failed: ${error instanceof Error ? error.message : String(error)}`);
+            this.outputManager.emitAgentError(error);
+            throw error;
+        } finally{
+            if (this.mcpManager) {
+                this.logger.debug("Cleaning up MCP client");
+                await this.mcpManager.cleanup();
+                this.mcpManager = null;
+            }
+        }
+    }
+    listAgents() {
+        const agents = this.findAllAgents();
+        return agents.map((a)=>({
+                name: a.name,
+                description: a.description
+            }));
+    }
+    constructor(options){
+        _define_property(this, "loader", void 0);
+        _define_property(this, "outputManager", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "wingmanConfig", void 0);
+        _define_property(this, "mcpManager", null);
+        _define_property(this, "sessionManager", null);
+        _define_property(this, "workdir", null);
+        _define_property(this, "defaultOutputDir", null);
+        this.outputManager = options.outputManager;
+        this.logger = options.logger;
+        this.workspace = options.workspace || process.cwd();
+        this.configDir = options.configDir || ".wingman";
+        this.sessionManager = options.sessionManager || null;
+        this.workdir = options.workdir || null;
+        this.defaultOutputDir = options.defaultOutputDir || null;
+        const configLoader = new WingmanConfigLoader(this.configDir, this.workspace);
+        this.wingmanConfig = configLoader.loadConfig();
+        this.loader = new AgentLoader(this.configDir, this.workspace, this.wingmanConfig);
+    }
+}
+function buildUserContent(prompt, attachments) {
+    const text = prompt?.trim() ?? "";
+    if (!attachments || 0 === attachments.length) return text;
+    const parts = [];
+    if (text) parts.push({
+        type: "text",
+        text
+    });
+    for (const attachment of attachments)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.");
+        return text;
+    }
+    return parts;
+}
+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 buildAudioPart(attachment) {
+    const parsed = parseDataUrl(attachment.dataUrl);
+    const mimeType = attachment.mimeType || parsed.mimeType;
+    if (parsed.data) return {
+        type: "audio",
+        source_type: "base64",
+        data: parsed.data,
+        mime_type: mimeType
+    };
+    return {
+        type: "audio",
+        source_type: "url",
+        url: attachment.dataUrl,
+        mime_type: mimeType
+    };
+}
+function parseDataUrl(dataUrl) {
+    if (!dataUrl.startsWith("data:")) return {};
+    const match = dataUrl.match(/^data:([^;]+);base64,(.+)$/);
+    if (!match) return {};
+    return {
+        mimeType: match[1],
+        data: match[2]
+    };
+}
+function buildAttachmentPreview(attachments) {
+    let hasAudio = false;
+    let hasImage = false;
+    for (const attachment of attachments)if (isAudioAttachment(attachment)) hasAudio = true;
+    else hasImage = true;
+    if (hasAudio && hasImage) return "[attachments]";
+    if (hasAudio) return "[audio]";
+    if (hasImage) return "[image]";
+    return "";
+}
+export { AgentInvoker, buildUserContent };