@wingman-ai/gateway 0.2.0 → 0.2.2

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

@@ -67,6 +67,45 @@ describe("Agent Configuration Schema", ()=>{
             expect(result.success).toBe(true);
             if (result.success) expect(result.data.subAgents?.[0].model).toBe("openai:gpt-4o");
         });
+        it("should fail when a sub-agent shares the same name as its parent", ()=>{
+            const config = {
+                name: "coding",
+                description: "Parent coding agent",
+                systemPrompt: "You are the parent coding agent",
+                subAgents: [
+                    {
+                        name: "coding",
+                        description: "Nested coding worker",
+                        systemPrompt: "You are a worker"
+                    }
+                ]
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(false);
+            if (!result.success) expect(result.error).toContain("Sub-agent name must be different from parent agent name");
+        });
+        it("should fail when sub-agent names are duplicated", ()=>{
+            const config = {
+                name: "parent-agent",
+                description: "Parent agent",
+                systemPrompt: "You are the parent agent",
+                subAgents: [
+                    {
+                        name: "implementor",
+                        description: "First implementor",
+                        systemPrompt: "You implement changes"
+                    },
+                    {
+                        name: "IMPLEMENTOR",
+                        description: "Duplicate implementor",
+                        systemPrompt: "You implement more changes"
+                    }
+                ]
+            };
+            const result = validateAgentConfig(config);
+            expect(result.success).toBe(false);
+            if (!result.success) expect(result.error).toContain("Sub-agent names must be unique within the same parent agent");
+        });
         it("should fail validation for missing required fields", ()=>{
             const config = {
                 name: "test-agent"

package/dist/cli/core/agentInvoker.cjs

@@ -96,7 +96,9 @@ class AgentInvoker {
     async findAgent(name) {
         return await this.loader.loadAgent(name);
     }
-    async invokeAgent(agentName, prompt, sessionId, attachments) {
+    async invokeAgent(agentName, prompt, sessionId, attachments, options) {
+        let cancellationHandled = false;
+        const isCancelled = ()=>options?.signal?.aborted === true;
         try {
             const executionWorkspace = resolveExecutionWorkspace(this.workspace, this.workdir);
             const effectiveWorkdir = this.workdir ? executionWorkspace : null;
@@ -211,9 +213,29 @@ class AgentInvoker {
                     configurable: {
                         thread_id: sessionId
                     },
-                    version: "v2"
+                    version: "v2",
+                    signal: options?.signal
                 });
-                for await (const chunk of stream)this.outputManager.emitAgentStream(chunk);
+                for await (const chunk of stream){
+                    if (isCancelled()) {
+                        cancellationHandled = true;
+                        this.logger.info("Agent invocation cancelled");
+                        this.outputManager.emitAgentError("Request cancelled");
+                        if ("function" == typeof stream?.return) await stream.return();
+                        return {
+                            cancelled: true
+                        };
+                    }
+                    this.outputManager.emitAgentStream(chunk);
+                }
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 this.logger.info("Agent streaming completed successfully");
                 this.outputManager.emitAgentComplete({
                     streaming: true
@@ -224,6 +246,14 @@ class AgentInvoker {
             }
             {
                 this.logger.debug("Using blocking invoke (no session manager)");
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 const result = await standaloneAgent.invoke({
                     messages: [
                         {
@@ -232,13 +262,30 @@ class AgentInvoker {
                         }
                     ]
                 }, {
-                    recursionLimit: this.wingmanConfig.recursionLimit
+                    recursionLimit: this.wingmanConfig.recursionLimit,
+                    signal: options?.signal
                 });
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 this.logger.info("Agent completed successfully");
                 this.outputManager.emitAgentComplete(result);
                 return result;
             }
         } catch (error) {
+            const abortError = isCancelled() || error instanceof Error && ("AbortError" === error.name || "CancelledError" === error.name || /abort|cancel/i.test(error.message));
+            if (abortError) {
+                if (!cancellationHandled) this.outputManager.emitAgentError("Request cancelled");
+                this.logger.info("Agent invocation cancelled");
+                return {
+                    cancelled: true
+                };
+            }
             this.logger.error(`Agent invocation failed: ${error instanceof Error ? error.message : String(error)}`);
             this.outputManager.emitAgentError(error);
             throw error;

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

@@ -12,6 +12,9 @@ export interface AgentInvokerOptions {
     workdir?: string | null;
     defaultOutputDir?: string | null;
 }
+export interface InvokeAgentOptions {
+    signal?: AbortSignal;
+}
 export type ImageAttachment = {
     kind?: "image";
     dataUrl: string;
@@ -99,7 +102,7 @@ export declare class AgentInvoker {
     /**
      * Invoke a specific agent directly (bypassing main orchestration)
      */
-    invokeAgent(agentName: string, prompt: string, sessionId?: string, attachments?: MediaAttachment[]): Promise<any>;
+    invokeAgent(agentName: string, prompt: string, sessionId?: string, attachments?: MediaAttachment[], options?: InvokeAgentOptions): Promise<any>;
     /**
      * List all available agents with their descriptions
      */

package/dist/cli/core/agentInvoker.js

@@ -62,7 +62,9 @@ class AgentInvoker {
     async findAgent(name) {
         return await this.loader.loadAgent(name);
     }
-    async invokeAgent(agentName, prompt, sessionId, attachments) {
+    async invokeAgent(agentName, prompt, sessionId, attachments, options) {
+        let cancellationHandled = false;
+        const isCancelled = ()=>options?.signal?.aborted === true;
         try {
             const executionWorkspace = resolveExecutionWorkspace(this.workspace, this.workdir);
             const effectiveWorkdir = this.workdir ? executionWorkspace : null;
@@ -177,9 +179,29 @@ class AgentInvoker {
                     configurable: {
                         thread_id: sessionId
                     },
-                    version: "v2"
+                    version: "v2",
+                    signal: options?.signal
                 });
-                for await (const chunk of stream)this.outputManager.emitAgentStream(chunk);
+                for await (const chunk of stream){
+                    if (isCancelled()) {
+                        cancellationHandled = true;
+                        this.logger.info("Agent invocation cancelled");
+                        this.outputManager.emitAgentError("Request cancelled");
+                        if ("function" == typeof stream?.return) await stream.return();
+                        return {
+                            cancelled: true
+                        };
+                    }
+                    this.outputManager.emitAgentStream(chunk);
+                }
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 this.logger.info("Agent streaming completed successfully");
                 this.outputManager.emitAgentComplete({
                     streaming: true
@@ -190,6 +212,14 @@ class AgentInvoker {
             }
             {
                 this.logger.debug("Using blocking invoke (no session manager)");
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 const result = await standaloneAgent.invoke({
                     messages: [
                         {
@@ -198,13 +228,30 @@ class AgentInvoker {
                         }
                     ]
                 }, {
-                    recursionLimit: this.wingmanConfig.recursionLimit
+                    recursionLimit: this.wingmanConfig.recursionLimit,
+                    signal: options?.signal
                 });
+                if (isCancelled()) {
+                    cancellationHandled = true;
+                    this.logger.info("Agent invocation cancelled");
+                    this.outputManager.emitAgentError("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
                 this.logger.info("Agent completed successfully");
                 this.outputManager.emitAgentComplete(result);
                 return result;
             }
         } catch (error) {
+            const abortError = isCancelled() || error instanceof Error && ("AbortError" === error.name || "CancelledError" === error.name || /abort|cancel/i.test(error.message));
+            if (abortError) {
+                if (!cancellationHandled) this.outputManager.emitAgentError("Request cancelled");
+                this.logger.info("Agent invocation cancelled");
+                return {
+                    cancelled: true
+                };
+            }
             this.logger.error(`Agent invocation failed: ${error instanceof Error ? error.message : String(error)}`);
             this.outputManager.emitAgentError(error);
             throw error;

package/dist/gateway/server.cjs

@@ -249,6 +249,7 @@ class GatewayServer {
             const nodeId = ws.data.nodeId;
             if ("connect" === msg.type) return void this.handleConnect(ws, msg);
             if ("req:agent" === msg.type) return void this.handleAgentRequest(ws, msg);
+            if ("req:agent:cancel" === msg.type) return void this.handleAgentCancel(ws, msg);
             if (nodeId && "register" !== msg.type && "ping" !== msg.type && "pong" !== msg.type) {
                 if (this.nodeManager.isRateLimited(nodeId)) return void this.sendError(ws, "RATE_LIMITED", "Too many messages. Please slow down.");
                 this.nodeManager.recordMessage(nodeId);
@@ -303,6 +304,7 @@ class GatewayServer {
         }
         this.connectedClients.delete(ws);
         this.clearSessionSubscriptions(ws);
+        this.cancelSocketAgentRequests(ws);
     }
     handleDrain(ws) {
         this.log("debug", "WebSocket drained");
@@ -343,6 +345,11 @@ class GatewayServer {
     async handleAgentRequest(ws, msg) {
         if (!msg.id) return void this.sendError(ws, "INVALID_REQUEST", "Missing request id");
         if (!ws.data.authenticated) return void this.sendAgentError(ws, msg.id, "Client is not authenticated");
+        if (this.activeAgentRequests.has(msg.id)) {
+            const existing = this.activeAgentRequests.get(msg.id);
+            existing?.abortController.abort();
+            this.activeAgentRequests.delete(msg.id);
+        }
         const payload = msg.payload;
         const content = "string" == typeof payload?.content ? payload.content : "";
         const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
@@ -428,8 +435,15 @@ class GatewayServer {
             workdir,
             defaultOutputDir
         });
+        const abortController = new AbortController();
+        this.activeAgentRequests.set(msg.id, {
+            socket: ws,
+            abortController
+        });
         try {
-            await invoker.invokeAgent(agentId, content, sessionKey, attachments);
+            await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
+                signal: abortController.signal
+            });
             const updated = sessionManager.getSession(sessionKey);
             if (updated) sessionManager.updateSession(sessionKey, {
                 messageCount: updated.messageCount + 1
@@ -437,9 +451,40 @@ class GatewayServer {
         } catch (error) {
             this.logger.error("Agent invocation failed", error);
         } finally{
+            this.activeAgentRequests.delete(msg.id);
             outputManager.off("output-event", outputHandler);
         }
     }
+    handleAgentCancel(ws, msg) {
+        if (!ws.data.authenticated) return void this.sendError(ws, "AUTH_FAILED", "Client is not authenticated");
+        const payload = msg.payload;
+        const requestId = "string" == typeof payload?.requestId && payload.requestId || void 0;
+        if (!requestId) return void this.sendError(ws, "INVALID_REQUEST", "Missing requestId for cancellation");
+        const active = this.activeAgentRequests.get(requestId);
+        if (!active) return void this.sendMessage(ws, {
+            type: "ack",
+            id: msg.id,
+            payload: {
+                action: "req:agent:cancel",
+                requestId,
+                status: "not_found"
+            },
+            timestamp: Date.now()
+        });
+        if (active.socket !== ws) return void this.sendError(ws, "FORBIDDEN", "Cannot cancel a request started by another client");
+        active.abortController.abort();
+        this.activeAgentRequests.delete(requestId);
+        this.sendMessage(ws, {
+            type: "ack",
+            id: msg.id,
+            payload: {
+                action: "req:agent:cancel",
+                requestId,
+                status: "cancelled"
+            },
+            timestamp: Date.now()
+        });
+    }
     handleRegister(ws, msg) {
         const payload = msg.payload;
         if (!this.auth.validate({
@@ -614,6 +659,12 @@ class GatewayServer {
             timestamp: Date.now()
         });
     }
+    cancelSocketAgentRequests(ws) {
+        for (const [requestId, active] of this.activeAgentRequests)if (active.socket === ws) {
+            active.abortController.abort();
+            this.activeAgentRequests.delete(requestId);
+        }
+    }
     attachSessionContext(event, sessionId, agentId) {
         if (event && "object" == typeof event && !Array.isArray(event)) return {
             ...event,
@@ -1129,6 +1180,7 @@ class GatewayServer {
         _define_property(this, "sessionSubscriptions", new Map());
         _define_property(this, "socketSubscriptions", new Map());
         _define_property(this, "connectedClients", new Set());
+        _define_property(this, "activeAgentRequests", new Map());
         _define_property(this, "bridgeQueues", new Map());
         _define_property(this, "bridgePollWaiters", new Map());
         this.workspace = config.workspace || process.cwd();

package/dist/gateway/server.d.ts

@@ -33,6 +33,7 @@ export declare class GatewayServer {
     private sessionSubscriptions;
     private socketSubscriptions;
     private connectedClients;
+    private activeAgentRequests;
     private bridgeQueues;
     private bridgePollWaiters;
     constructor(config?: Partial<GatewayConfig>);
@@ -75,6 +76,7 @@ export declare class GatewayServer {
      * Handle agent execution request
      */
     private handleAgentRequest;
+    private handleAgentCancel;
     /**
      * Handle node registration
      */
@@ -124,6 +126,7 @@ export declare class GatewayServer {
      */
     private sendError;
     private sendAgentError;
+    private cancelSocketAgentRequests;
     private attachSessionContext;
     private broadcastSessionEvent;
     private broadcastToClients;

package/dist/gateway/server.js

@@ -218,6 +218,7 @@ class GatewayServer {
             const nodeId = ws.data.nodeId;
             if ("connect" === msg.type) return void this.handleConnect(ws, msg);
             if ("req:agent" === msg.type) return void this.handleAgentRequest(ws, msg);
+            if ("req:agent:cancel" === msg.type) return void this.handleAgentCancel(ws, msg);
             if (nodeId && "register" !== msg.type && "ping" !== msg.type && "pong" !== msg.type) {
                 if (this.nodeManager.isRateLimited(nodeId)) return void this.sendError(ws, "RATE_LIMITED", "Too many messages. Please slow down.");
                 this.nodeManager.recordMessage(nodeId);
@@ -272,6 +273,7 @@ class GatewayServer {
         }
         this.connectedClients.delete(ws);
         this.clearSessionSubscriptions(ws);
+        this.cancelSocketAgentRequests(ws);
     }
     handleDrain(ws) {
         this.log("debug", "WebSocket drained");
@@ -312,6 +314,11 @@ class GatewayServer {
     async handleAgentRequest(ws, msg) {
         if (!msg.id) return void this.sendError(ws, "INVALID_REQUEST", "Missing request id");
         if (!ws.data.authenticated) return void this.sendAgentError(ws, msg.id, "Client is not authenticated");
+        if (this.activeAgentRequests.has(msg.id)) {
+            const existing = this.activeAgentRequests.get(msg.id);
+            existing?.abortController.abort();
+            this.activeAgentRequests.delete(msg.id);
+        }
         const payload = msg.payload;
         const content = "string" == typeof payload?.content ? payload.content : "";
         const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
@@ -397,8 +404,15 @@ class GatewayServer {
             workdir,
             defaultOutputDir
         });
+        const abortController = new AbortController();
+        this.activeAgentRequests.set(msg.id, {
+            socket: ws,
+            abortController
+        });
         try {
-            await invoker.invokeAgent(agentId, content, sessionKey, attachments);
+            await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
+                signal: abortController.signal
+            });
             const updated = sessionManager.getSession(sessionKey);
             if (updated) sessionManager.updateSession(sessionKey, {
                 messageCount: updated.messageCount + 1
@@ -406,9 +420,40 @@ class GatewayServer {
         } catch (error) {
             this.logger.error("Agent invocation failed", error);
         } finally{
+            this.activeAgentRequests.delete(msg.id);
             outputManager.off("output-event", outputHandler);
         }
     }
+    handleAgentCancel(ws, msg) {
+        if (!ws.data.authenticated) return void this.sendError(ws, "AUTH_FAILED", "Client is not authenticated");
+        const payload = msg.payload;
+        const requestId = "string" == typeof payload?.requestId && payload.requestId || void 0;
+        if (!requestId) return void this.sendError(ws, "INVALID_REQUEST", "Missing requestId for cancellation");
+        const active = this.activeAgentRequests.get(requestId);
+        if (!active) return void this.sendMessage(ws, {
+            type: "ack",
+            id: msg.id,
+            payload: {
+                action: "req:agent:cancel",
+                requestId,
+                status: "not_found"
+            },
+            timestamp: Date.now()
+        });
+        if (active.socket !== ws) return void this.sendError(ws, "FORBIDDEN", "Cannot cancel a request started by another client");
+        active.abortController.abort();
+        this.activeAgentRequests.delete(requestId);
+        this.sendMessage(ws, {
+            type: "ack",
+            id: msg.id,
+            payload: {
+                action: "req:agent:cancel",
+                requestId,
+                status: "cancelled"
+            },
+            timestamp: Date.now()
+        });
+    }
     handleRegister(ws, msg) {
         const payload = msg.payload;
         if (!this.auth.validate({
@@ -583,6 +628,12 @@ class GatewayServer {
             timestamp: Date.now()
         });
     }
+    cancelSocketAgentRequests(ws) {
+        for (const [requestId, active] of this.activeAgentRequests)if (active.socket === ws) {
+            active.abortController.abort();
+            this.activeAgentRequests.delete(requestId);
+        }
+    }
     attachSessionContext(event, sessionId, agentId) {
         if (event && "object" == typeof event && !Array.isArray(event)) return {
             ...event,
@@ -1098,6 +1149,7 @@ class GatewayServer {
         _define_property(this, "sessionSubscriptions", new Map());
         _define_property(this, "socketSubscriptions", new Map());
         _define_property(this, "connectedClients", new Set());
+        _define_property(this, "activeAgentRequests", new Map());
         _define_property(this, "bridgeQueues", new Map());
         _define_property(this, "bridgePollWaiters", new Map());
         this.workspace = config.workspace || process.cwd();

package/dist/gateway/types.d.ts

@@ -2,7 +2,7 @@ import type { ServerWebSocket } from "bun";
 /**
  * Message types for gateway communication
  */
-export type MessageType = "connect" | "res" | "req:agent" | "event:agent" | "session_subscribe" | "session_unsubscribe" | "register" | "registered" | "unregister" | "join_group" | "leave_group" | "broadcast" | "direct" | "ping" | "pong" | "error" | "ack" | "upgrade";
+export type MessageType = "connect" | "res" | "req:agent" | "req:agent:cancel" | "event:agent" | "session_subscribe" | "session_unsubscribe" | "register" | "registered" | "unregister" | "join_group" | "leave_group" | "broadcast" | "direct" | "ping" | "pong" | "error" | "ack" | "upgrade";
 /**
  * Gateway message structure
  */
@@ -61,6 +61,9 @@ export interface AgentRequestPayload {
     routing?: RoutingInfo;
     sessionKey?: string;
 }
+export interface AgentCancelPayload {
+    requestId: string;
+}
 export interface RoutingPeer {
     kind: "dm" | "group" | "channel";
     id: string;

package/dist/gateway/validation.cjs

@@ -42,6 +42,7 @@ const MessageTypeSchema = external_zod_namespaceObject.z["enum"]([
     "connect",
     "res",
     "req:agent",
+    "req:agent:cancel",
     "event:agent",
     "session_subscribe",
     "session_unsubscribe",

package/dist/gateway/validation.d.ts

@@ -8,6 +8,7 @@ export declare const MessageTypeSchema: z.ZodEnum<{
     connect: "connect";
     res: "res";
     "req:agent": "req:agent";
+    "req:agent:cancel": "req:agent:cancel";
     "event:agent": "event:agent";
     session_subscribe: "session_subscribe";
     session_unsubscribe: "session_unsubscribe";
@@ -31,6 +32,7 @@ export declare const GatewayMessageSchema: z.ZodObject<{
         connect: "connect";
         res: "res";
         "req:agent": "req:agent";
+        "req:agent:cancel": "req:agent:cancel";
         "event:agent": "event:agent";
         session_subscribe: "session_subscribe";
         session_unsubscribe: "session_unsubscribe";

package/dist/gateway/validation.js

@@ -3,6 +3,7 @@ const MessageTypeSchema = z["enum"]([
     "connect",
     "res",
     "req:agent",
+    "req:agent:cancel",
     "event:agent",
     "session_subscribe",
     "session_unsubscribe",

package/dist/tests/gateway.test.cjs

@@ -2,15 +2,52 @@
 var __webpack_exports__ = {};
 const external_vitest_namespaceObject = require("vitest");
 const index_cjs_namespaceObject = require("../gateway/index.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;
+}
 const isBun = void 0 !== globalThis.Bun;
 const describeIfBun = isBun ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
 external_vitest_namespaceObject.vi.mock("@/cli/core/agentInvoker.js", ()=>({
         AgentInvoker: class {
-            async invokeAgent() {
+            async invokeAgent(_agentId, _content, _sessionId, _attachments, options) {
+                const signal = options?.signal;
+                await new Promise((resolve)=>{
+                    const timer = setTimeout(resolve, 75);
+                    if (signal) {
+                        const onAbort = ()=>{
+                            clearTimeout(timer);
+                            resolve();
+                        };
+                        if (signal.aborted) return void onAbort();
+                        signal.addEventListener("abort", onAbort, {
+                            once: true
+                        });
+                    }
+                });
+                if (signal?.aborted) {
+                    this.outputManager?.emitAgentError?.("Request cancelled");
+                    return {
+                        cancelled: true
+                    };
+                }
+                this.outputManager?.emitAgentComplete?.({
+                    streaming: true
+                });
                 return {
                     streaming: true
                 };
             }
+            constructor(options){
+                _define_property(this, "outputManager", void 0);
+                this.outputManager = options?.outputManager;
+            }
         }
     }));
 describeIfBun("Gateway", ()=>{
@@ -296,6 +333,34 @@ describeIfBun("Gateway", ()=>{
         desktopClient.close();
         requester.close();
     });
+    (0, external_vitest_namespaceObject.it)("should cancel an in-flight agent request", async ()=>{
+        const requester = await connectClient("session-cancel-requester");
+        const requestId = "req-cancel-test";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: "session-cancel-test",
+                content: "cancel me"
+            },
+            timestamp: Date.now()
+        }));
+        requester.send(JSON.stringify({
+            type: "req:agent:cancel",
+            id: "cancel-req-cancel-test",
+            payload: {
+                requestId
+            },
+            timestamp: Date.now()
+        }));
+        const ack = await waitForMessage(requester, (msg)=>"ack" === msg.type && msg.payload?.action === "req:agent:cancel" && msg.payload?.requestId === requestId);
+        (0, external_vitest_namespaceObject.expect)([
+            "cancelled",
+            "not_found"
+        ]).toContain(ack.payload?.status);
+        requester.close();
+    });
     (0, external_vitest_namespaceObject.it)("should clear session messages via API", async ()=>{
         const createRes = await fetch(`http://localhost:${port}/api/sessions`, {
             method: "POST",