@wingman-ai/gateway 0.2.2 → 0.2.4

package/dist/tests/gateway.test.js

@@ -14,7 +14,8 @@ const isBun = void 0 !== globalThis.Bun;
 const describeIfBun = isBun ? describe : describe.skip;
 vi.mock("@/cli/core/agentInvoker.js", ()=>({
         AgentInvoker: class {
-            async invokeAgent(_agentId, _content, _sessionId, _attachments, options) {
+            async invokeAgent(_agentId, content, _sessionId, _attachments, options) {
+                if ("throw-no-event" === content) throw new Error("Synthetic invocation failure");
                 const signal = options?.signal;
                 await new Promise((resolve)=>{
                     const timer = setTimeout(resolve, 75);
@@ -173,14 +174,15 @@ describeIfBun("Gateway", ()=>{
         }));
     it("should broadcast messages to group members", async ()=>new Promise((resolve, reject)=>{
             let client1NodeId = null;
-            let messagesReceived = 0;
+            let broadcastGroupId = null;
             const client1 = new GatewayClient(`ws://localhost:${port}/ws`, "broadcaster", {
                 events: {
                     registered: async (nodeId)=>{
                         client1NodeId = nodeId;
                         await client1.joinGroup("broadcast-test");
                     },
-                    joinedGroup: ()=>{
+                    joinedGroup: (groupId)=>{
+                        broadcastGroupId = groupId;
                         client2.connect().catch(reject);
                     }
                 }
@@ -191,14 +193,13 @@ describeIfBun("Gateway", ()=>{
                         await client2.joinGroup("broadcast-test");
                     },
                     joinedGroup: ()=>{
-                        client1.broadcast("broadcast-test", {
+                        client1.broadcast(broadcastGroupId || "broadcast-test", {
                             message: "Hello from client 1"
                         });
                     },
                     broadcast: (message, fromNodeId)=>{
                         expect(fromNodeId).toBe(client1NodeId);
                         expect(message.message).toBe("Hello from client 1");
-                        messagesReceived++;
                         client1.disconnect();
                         client2.disconnect();
                         resolve();
@@ -331,6 +332,26 @@ describeIfBun("Gateway", ()=>{
         desktopClient.close();
         requester.close();
     });
+    it("should emit agent-error to requester when invocation throws without emitting", async ()=>{
+        const requester = await connectClient("session-error-requester");
+        const requestId = "req-invocation-error";
+        const sessionId = "session-error-test";
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: requestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "throw-no-event"
+            },
+            timestamp: Date.now()
+        }));
+        const errorMsg = await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === requestId && msg.payload?.type === "agent-error");
+        expect(errorMsg.payload?.error).toContain("Synthetic invocation failure");
+        expect(errorMsg.payload?.sessionId).toBe(sessionId);
+        expect(errorMsg.payload?.agentId).toBe("main");
+        requester.close();
+    });
     it("should cancel an in-flight agent request", async ()=>{
         const requester = await connectClient("session-cancel-requester");
         const requestId = "req-cancel-test";
@@ -359,6 +380,92 @@ describeIfBun("Gateway", ()=>{
         ]).toContain(ack.payload?.status);
         requester.close();
     });
+    it("should queue and dequeue requests for the same session", async ()=>{
+        const requester = await connectClient("session-queue-requester");
+        const sessionId = `session-queue-${Date.now()}`;
+        const firstRequestId = `req-queue-first-${Date.now()}`;
+        const secondRequestId = `req-queue-second-${Date.now()}`;
+        const firstCompletePromise = waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === firstRequestId && msg.payload?.type === "agent-complete", 10000);
+        const queuedAckPromise = waitForMessage(requester, (msg)=>"ack" === msg.type && msg.id === secondRequestId && msg.payload?.action === "req:agent" && msg.payload?.status === "queued", 10000);
+        const queuedEventPromise = waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === secondRequestId && msg.payload?.type === "request-queued", 10000);
+        const dequeuedAckPromise = waitForMessage(requester, (msg)=>"ack" === msg.type && msg.id === secondRequestId && msg.payload?.action === "req:agent" && msg.payload?.status === "dequeued", 10000);
+        const secondCompletePromise = waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === secondRequestId && msg.payload?.type === "agent-complete", 10000);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: firstRequestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "First queued request"
+            },
+            timestamp: Date.now()
+        }));
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: secondRequestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Second queued request"
+            },
+            timestamp: Date.now()
+        }));
+        const queuedAck = await queuedAckPromise;
+        expect(queuedAck.payload?.position).toBe(1);
+        const queuedEvent = await queuedEventPromise;
+        expect(queuedEvent.payload?.position).toBe(1);
+        expect(queuedEvent.payload?.sessionId).toBe(sessionId);
+        await firstCompletePromise;
+        const dequeuedAck = await dequeuedAckPromise;
+        expect(dequeuedAck.payload?.remaining).toBe(0);
+        await secondCompletePromise;
+        requester.close();
+    });
+    it("should cancel a queued request", async ()=>{
+        const requester = await connectClient("session-cancel-queued-requester");
+        const sessionId = `session-cancel-queued-${Date.now()}`;
+        const firstRequestId = `req-cancel-queued-first-${Date.now()}`;
+        const secondRequestId = `req-cancel-queued-second-${Date.now()}`;
+        const queuedAckPromise = waitForMessage(requester, (msg)=>"ack" === msg.type && msg.id === secondRequestId && msg.payload?.action === "req:agent" && msg.payload?.status === "queued", 10000);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: firstRequestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "First request"
+            },
+            timestamp: Date.now()
+        }));
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: secondRequestId,
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Second request"
+            },
+            timestamp: Date.now()
+        }));
+        await queuedAckPromise;
+        requester.send(JSON.stringify({
+            type: "req:agent:cancel",
+            id: `cancel-${secondRequestId}`,
+            payload: {
+                requestId: secondRequestId
+            },
+            timestamp: Date.now()
+        }));
+        const cancelAck = await waitForMessage(requester, (msg)=>"ack" === msg.type && msg.payload?.action === "req:agent:cancel" && msg.payload?.requestId === secondRequestId && msg.payload?.status === "cancelled_queued", 10000);
+        expect(cancelAck.payload?.status).toBe("cancelled_queued");
+        await waitForMessage(requester, (msg)=>"event:agent" === msg.type && msg.id === firstRequestId && msg.payload?.type === "agent-complete", 10000);
+        const queuedRequests = server.queuedSessionRequests;
+        const isStillQueued = [
+            ...queuedRequests.values()
+        ].some((queue)=>queue.some((item)=>item.msg?.id === secondRequestId));
+        expect(isStillQueued).toBe(false);
+        requester.close();
+    });
     it("should clear session messages via API", async ()=>{
         const createRes = await fetch(`http://localhost:${port}/api/sessions`, {
             method: "POST",
@@ -366,18 +473,18 @@ describeIfBun("Gateway", ()=>{
                 "Content-Type": "application/json"
             },
             body: JSON.stringify({
-                agentId: "main",
                 name: "Clear Test"
             })
         });
         expect(createRes.ok).toBe(true);
         const session = await createRes.json();
-        const manager = await server.getSessionManager("main");
+        const sessionAgentId = session.agentId || "main";
+        const manager = await server.getSessionManager(sessionAgentId);
         manager.updateSession(session.id, {
             messageCount: 3,
             lastMessagePreview: "Hello"
         });
-        const clearRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(session.id)}/messages?agentId=main`, {
+        const clearRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(session.id)}/messages?agentId=${encodeURIComponent(sessionAgentId)}`, {
             method: "DELETE"
         });
         expect(clearRes.ok).toBe(true);

package/dist/tests/provider-command-codex.test.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_vitest_namespaceObject = require("vitest");
+const provider_cjs_namespaceObject = require("../cli/commands/provider.cjs");
+const codex_cjs_namespaceObject = require("../providers/codex.cjs");
+(0, external_vitest_namespaceObject.describe)("provider command codex login", ()=>{
+    let codexHome;
+    const originalCodexHome = process.env.CODEX_HOME;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        codexHome = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-provider-codex-"));
+        process.env.CODEX_HOME = codexHome;
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if ((0, external_node_fs_namespaceObject.existsSync)(codexHome)) (0, external_node_fs_namespaceObject.rmSync)(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("uses existing codex login without requiring a token", async ()=>{
+        const authPath = (0, codex_cjs_namespaceObject.getCodexAuthPath)();
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(authPath), {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-access-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const exitSpy = external_vitest_namespaceObject.vi.spyOn(process, "exit").mockImplementation((code)=>{
+            throw new Error(`process.exit(${code ?? "undefined"})`);
+        });
+        try {
+            await (0, external_vitest_namespaceObject.expect)((0, provider_cjs_namespaceObject.executeProviderCommand)({
+                subcommand: "login",
+                args: [
+                    "codex"
+                ],
+                verbosity: "silent",
+                outputMode: "json",
+                options: {}
+            })).resolves.toBeUndefined();
+            (0, external_vitest_namespaceObject.expect)(exitSpy).not.toHaveBeenCalled();
+        } finally{
+            exitSpy.mockRestore();
+        }
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/provider-command-codex.test.d.ts

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

package/dist/tests/provider-command-codex.test.js

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { executeProviderCommand } from "../cli/commands/provider.js";
+import { getCodexAuthPath } from "../providers/codex.js";
+describe("provider command codex login", ()=>{
+    let codexHome;
+    const originalCodexHome = process.env.CODEX_HOME;
+    beforeEach(()=>{
+        codexHome = mkdtempSync(join(tmpdir(), "wingman-provider-codex-"));
+        process.env.CODEX_HOME = codexHome;
+    });
+    afterEach(()=>{
+        if (void 0 === originalCodexHome) delete process.env.CODEX_HOME;
+        else process.env.CODEX_HOME = originalCodexHome;
+        if (existsSync(codexHome)) rmSync(codexHome, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("uses existing codex login without requiring a token", async ()=>{
+        const authPath = getCodexAuthPath();
+        mkdirSync(dirname(authPath), {
+            recursive: true
+        });
+        writeFileSync(authPath, JSON.stringify({
+            tokens: {
+                access_token: "codex-access-token",
+                account_id: "acct_123"
+            }
+        }, null, 2));
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation((code)=>{
+            throw new Error(`process.exit(${code ?? "undefined"})`);
+        });
+        try {
+            await expect(executeProviderCommand({
+                subcommand: "login",
+                args: [
+                    "codex"
+                ],
+                verbosity: "silent",
+                outputMode: "json",
+                options: {}
+            })).resolves.toBeUndefined();
+            expect(exitSpy).not.toHaveBeenCalled();
+        } finally{
+            exitSpy.mockRestore();
+        }
+    });
+});

package/dist/tests/sessionStateMessages.test.cjs

@@ -65,6 +65,44 @@ const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.c
             content: "keep"
         });
     });
+    (0, external_vitest_namespaceObject.it)("extracts content from responses-style text blocks", ()=>{
+        const state = {
+            createdAt: 2000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Build a plan"
+                            }
+                        ]
+                    },
+                    {
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "output_text",
+                                text: "Here is the plan."
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = (0, sessionManager_cjs_namespaceObject.extractMessagesFromState)(state);
+        (0, external_vitest_namespaceObject.expect)(result).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(result).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(result?.[0]).toMatchObject({
+            role: "user",
+            content: "Build a plan"
+        });
+        (0, external_vitest_namespaceObject.expect)(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Here is the plan."
+        });
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/sessionStateMessages.test.js

@@ -63,4 +63,42 @@ describe("extractMessagesFromState", ()=>{
             content: "keep"
         });
     });
+    it("extracts content from responses-style text blocks", ()=>{
+        const state = {
+            createdAt: 2000,
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "input_text",
+                                text: "Build a plan"
+                            }
+                        ]
+                    },
+                    {
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "output_text",
+                                text: "Here is the plan."
+                            }
+                        ]
+                    }
+                ]
+            }
+        };
+        const result = extractMessagesFromState(state);
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+        expect(result?.[0]).toMatchObject({
+            role: "user",
+            content: "Build a plan"
+        });
+        expect(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "Here is the plan."
+        });
+    });
 });

package/dist/tests/toolDisplayHelpers.test.cjs

@@ -19,6 +19,9 @@ const toolDisplayHelpers_cjs_namespaceObject = require("../cli/ui/toolDisplayHel
         (0, external_vitest_namespaceObject.expect)((0, toolDisplayHelpers_cjs_namespaceObject.extractSubagentName)({
             subagent: "Runner"
         })).toBe("Runner");
+        (0, external_vitest_namespaceObject.expect)((0, toolDisplayHelpers_cjs_namespaceObject.extractSubagentName)({
+            subagent_type: "reviewer"
+        })).toBe("reviewer");
         (0, external_vitest_namespaceObject.expect)((0, toolDisplayHelpers_cjs_namespaceObject.extractSubagentName)({
             agent: {
                 name: "Writer"

package/dist/tests/toolDisplayHelpers.test.js

@@ -17,6 +17,9 @@ describe("toolDisplayHelpers", ()=>{
         expect(extractSubagentName({
             subagent: "Runner"
         })).toBe("Runner");
+        expect(extractSubagentName({
+            subagent_type: "reviewer"
+        })).toBe("reviewer");
         expect(extractSubagentName({
             agent: {
                 name: "Writer"

package/dist/tools/mcp-finance.cjs

@@ -246,8 +246,8 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.symbolSearch", {
                     title: "Finnhub Symbol Search",
                     description: "Search for symbols or companies by query.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        query: zod__rspack_import_2.z.string().min(1)
+                    inputSchema: zod__rspack_import_2.object({
+                        query: zod__rspack_import_2.string().min(1)
                     })
                 }, async ({ query })=>{
                     const data = await fetchFinnhub("/search", {
@@ -258,8 +258,8 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.quote", {
                     title: "Finnhub Quote",
                     description: "Get the latest quote for a symbol.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1)
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1)
                     })
                 }, async ({ symbol })=>{
                     const data = await fetchFinnhub("/quote", {
@@ -270,8 +270,8 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.companyProfile", {
                     title: "Finnhub Company Profile",
                     description: "Get company profile data for a symbol.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1)
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1)
                     })
                 }, async ({ symbol })=>{
                     const data = await fetchFinnhub("/stock/profile2", {
@@ -282,9 +282,9 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.financials", {
                     title: "Finnhub Financial Metrics",
                     description: "Get financial metrics (including P/E) for a symbol.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1),
-                        metric: zod__rspack_import_2.z.string().optional().default("all")
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1),
+                        metric: zod__rspack_import_2.string().optional().default("all")
                     })
                 }, async ({ symbol, metric })=>{
                     const data = await fetchFinnhub("/stock/metric", {
@@ -296,9 +296,9 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.earnings", {
                     title: "Finnhub Earnings",
                     description: "Get earnings history for a symbol.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1),
-                        limit: zod__rspack_import_2.z.number().int().min(1).max(20).optional()
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1),
+                        limit: zod__rspack_import_2.number().int().min(1).max(20).optional()
                     })
                 }, async ({ symbol, limit })=>{
                     const data = await fetchFinnhub("/stock/earnings", {
@@ -312,10 +312,10 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.news", {
                     title: "Finnhub Company News",
                     description: "Get recent company news for a symbol.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1),
-                        from: zod__rspack_import_2.z.string().optional(),
-                        to: zod__rspack_import_2.z.string().optional()
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1),
+                        from: zod__rspack_import_2.string().optional(),
+                        to: zod__rspack_import_2.string().optional()
                     })
                 }, async ({ symbol, from, to })=>{
                     const toDate = to || new Date().toISOString().slice(0, 10);
@@ -335,8 +335,8 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.marketNews", {
                     title: "Finnhub Market News",
                     description: "Get broad market news (general category) for theme detection.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        category: zod__rspack_import_2.z.string().min(1).optional().default("general")
+                    inputSchema: zod__rspack_import_2.object({
+                        category: zod__rspack_import_2.string().min(1).optional().default("general")
                     })
                 }, async ({ category })=>{
                     const data = await fetchFinnhub("/news", {
@@ -347,8 +347,8 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.peers", {
                     title: "Finnhub Stock Peers",
                     description: "Get peer symbols for a company.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1)
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1)
                     })
                 }, async ({ symbol })=>{
                     const data = await fetchFinnhub("/stock/peers", {
@@ -359,12 +359,12 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.candles", {
                     title: "Finnhub Candles",
                     description: `Get OHLCV candles for a symbol. ${candleCapSummary} ${candleSourceSummary} ${candleSessionSummary}`,
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1),
-                        resolution: zod__rspack_import_2.z.string().optional().default("D"),
-                        from: zod__rspack_import_2.z.number().int().optional(),
-                        to: zod__rspack_import_2.z.number().int().optional(),
-                        lookbackDays: zod__rspack_import_2.z.number().int().positive().optional()
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1),
+                        resolution: zod__rspack_import_2.string().optional().default("D"),
+                        from: zod__rspack_import_2.number().int().optional(),
+                        to: zod__rspack_import_2.number().int().optional(),
+                        lookbackDays: zod__rspack_import_2.number().int().positive().optional()
                     })
                 }, async ({ symbol, resolution, from, to, lookbackDays })=>{
                     const range = (0, _finance_candleRange_js__rspack_import_5.resolveCandleRange)({
@@ -390,12 +390,12 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.technicalSnapshot", {
                     title: "Finnhub Technical Snapshot",
                     description: `Fetch candles and compute RSI/EMA/ATR locally. ${candleCapSummary} ${candleSourceSummary} ${candleSessionSummary}`,
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1),
-                        resolution: zod__rspack_import_2.z.string().optional().default("D"),
-                        from: zod__rspack_import_2.z.number().int().optional(),
-                        to: zod__rspack_import_2.z.number().int().optional(),
-                        lookbackDays: zod__rspack_import_2.z.number().int().positive().optional()
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1),
+                        resolution: zod__rspack_import_2.string().optional().default("D"),
+                        from: zod__rspack_import_2.number().int().optional(),
+                        to: zod__rspack_import_2.number().int().optional(),
+                        lookbackDays: zod__rspack_import_2.number().int().positive().optional()
                     })
                 }, async ({ symbol, resolution, from, to, lookbackDays })=>{
                     const range = (0, _finance_candleRange_js__rspack_import_5.resolveCandleRange)({
@@ -440,9 +440,9 @@ var __webpack_modules__ = {
                 server.registerTool("finnhub.optionChain", {
                     title: "Finnhub Option Chain",
                     description: "Get option chain data for a symbol (date optional).",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        symbol: zod__rspack_import_2.z.string().min(1),
-                        date: zod__rspack_import_2.z.string().optional()
+                    inputSchema: zod__rspack_import_2.object({
+                        symbol: zod__rspack_import_2.string().min(1),
+                        date: zod__rspack_import_2.string().optional()
                     })
                 }, async ({ symbol, date })=>{
                     const data = await fetchFinnhub("/stock/option-chain", {
@@ -456,25 +456,25 @@ var __webpack_modules__ = {
                 server.registerTool("options.analyze", {
                     title: "Options Structure Analyzer",
                     description: "Compute payoff metrics and optional Greeks for an options structure using supplied leg prices.",
-                    inputSchema: zod__rspack_import_2.z.object({
-                        underlyingPrice: zod__rspack_import_2.z.number().positive(),
-                        daysToExpiry: zod__rspack_import_2.z.number().positive().optional(),
-                        riskFreeRate: zod__rspack_import_2.z.number().optional().default(0),
-                        dividendYield: zod__rspack_import_2.z.number().optional().default(0),
-                        legs: zod__rspack_import_2.z.array(zod__rspack_import_2.z.object({
-                            type: zod__rspack_import_2.z["enum"]([
+                    inputSchema: zod__rspack_import_2.object({
+                        underlyingPrice: zod__rspack_import_2.number().positive(),
+                        daysToExpiry: zod__rspack_import_2.number().positive().optional(),
+                        riskFreeRate: zod__rspack_import_2.number().optional().default(0),
+                        dividendYield: zod__rspack_import_2.number().optional().default(0),
+                        legs: zod__rspack_import_2.array(zod__rspack_import_2.object({
+                            type: zod__rspack_import_2["enum"]([
                                 "call",
                                 "put"
                             ]),
-                            side: zod__rspack_import_2.z["enum"]([
+                            side: zod__rspack_import_2["enum"]([
                                 "buy",
                                 "sell"
                             ]),
-                            strike: zod__rspack_import_2.z.number().positive(),
-                            premium: zod__rspack_import_2.z.number().nonnegative(),
-                            qty: zod__rspack_import_2.z.number().int().positive().optional(),
-                            contractMultiplier: zod__rspack_import_2.z.number().positive().optional(),
-                            impliedVol: zod__rspack_import_2.z.number().positive().optional()
+                            strike: zod__rspack_import_2.number().positive(),
+                            premium: zod__rspack_import_2.number().nonnegative(),
+                            qty: zod__rspack_import_2.number().int().positive().optional(),
+                            contractMultiplier: zod__rspack_import_2.number().positive().optional(),
+                            impliedVol: zod__rspack_import_2.number().positive().optional()
                         })).min(1)
                     })
                 }, async (input)=>{