@wingman-ai/gateway 0.1.0

package/dist/tests/integration/agent-invocation.integration.test.cjs

@@ -0,0 +1,264 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+const external_os_namespaceObject = require("os");
+(0, external_vitest_namespaceObject.describe)("Agent Invocation Integration", ()=>{
+    let testDir;
+    let configDir;
+    let agentsDir;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        testDir = (0, external_path_namespaceObject.join)((0, external_os_namespaceObject.tmpdir)(), `wingman-integration-${Date.now()}`);
+        configDir = (0, external_path_namespaceObject.join)(testDir, ".wingman");
+        agentsDir = (0, external_path_namespaceObject.join)(configDir, "agents");
+        (0, external_fs_namespaceObject.mkdirSync)(agentsDir, {
+            recursive: true
+        });
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if ((0, external_fs_namespaceObject.existsSync)(testDir)) (0, external_fs_namespaceObject.rmSync)(testDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Agent Loading", ()=>{
+        (0, external_vitest_namespaceObject.it)("should load agent with tools", ()=>{
+            const agentConfig = {
+                name: "test-agent",
+                description: "Test agent for integration testing",
+                systemPrompt: "You are a test agent",
+                tools: [
+                    "think",
+                    "internet_search"
+                ]
+            };
+            const agentDir = (0, external_path_namespaceObject.join)(agentsDir, "test-agent");
+            (0, external_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("test-agent");
+            (0, external_vitest_namespaceObject.expect)(agents[0].tools).toEqual([
+                "think",
+                "internet_search"
+            ]);
+        });
+        (0, external_vitest_namespaceObject.it)("should load multiple agents", ()=>{
+            const agent1Config = {
+                name: "agent1",
+                description: "First test agent",
+                systemPrompt: "You are agent 1",
+                tools: [
+                    "think"
+                ]
+            };
+            const agent2Config = {
+                name: "agent2",
+                description: "Second test agent",
+                systemPrompt: "You are agent 2",
+                tools: [
+                    "internet_search"
+                ]
+            };
+            const agent1Dir = (0, external_path_namespaceObject.join)(agentsDir, "agent1");
+            const agent2Dir = (0, external_path_namespaceObject.join)(agentsDir, "agent2");
+            (0, external_fs_namespaceObject.mkdirSync)(agent1Dir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.mkdirSync)(agent2Dir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agent1Dir, "agent.json"), JSON.stringify(agent1Config));
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agent2Dir, "agent.json"), JSON.stringify(agent2Config));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(2);
+            (0, external_vitest_namespaceObject.expect)(agents.map((a)=>a.name)).toContain("agent1");
+            (0, external_vitest_namespaceObject.expect)(agents.map((a)=>a.name)).toContain("agent2");
+        });
+        (0, external_vitest_namespaceObject.it)("should create agent with command_execute tool and safety options", ()=>{
+            const agentConfig = {
+                name: "coder-agent",
+                description: "Agent with command execution",
+                systemPrompt: "You are a coding agent",
+                tools: [
+                    "command_execute"
+                ],
+                blockedCommands: [
+                    "rm",
+                    "sudo"
+                ],
+                allowScriptExecution: false,
+                commandTimeout: 30000
+            };
+            const agentDir = (0, external_path_namespaceObject.join)(agentsDir, "coder-agent");
+            (0, external_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("coder-agent");
+            (0, external_vitest_namespaceObject.expect)(agents[0].tools).toEqual([
+                "command_execute"
+            ]);
+            (0, external_vitest_namespaceObject.expect)(agents[0].blockedCommands).toEqual([
+                "rm",
+                "sudo"
+            ]);
+            (0, external_vitest_namespaceObject.expect)(agents[0].allowScriptExecution).toBe(false);
+            (0, external_vitest_namespaceObject.expect)(agents[0].commandTimeout).toBe(30000);
+        });
+        (0, external_vitest_namespaceObject.it)("should find specific agent by name", async ()=>{
+            const agentConfig = {
+                name: "specific-agent",
+                description: "Specific test agent",
+                systemPrompt: "You are a specific agent"
+            };
+            const agentDir = (0, external_path_namespaceObject.join)(agentsDir, "specific-agent");
+            (0, external_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agent = await loader.loadAgent("specific-agent");
+            (0, external_vitest_namespaceObject.expect)(agent).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(agent?.name).toBe("specific-agent");
+        });
+        (0, external_vitest_namespaceObject.it)("should return undefined for non-existent agent", async ()=>{
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agent = await loader.loadAgent("non-existent-agent");
+            (0, external_vitest_namespaceObject.expect)(agent).toBeUndefined();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Agent Configuration Validation", ()=>{
+        (0, external_vitest_namespaceObject.it)("should skip agents with invalid configuration", ()=>{
+            const validConfig = {
+                name: "valid-agent",
+                description: "Valid agent",
+                systemPrompt: "You are valid"
+            };
+            const invalidConfig = {
+                name: "invalid-agent"
+            };
+            const validDir = (0, external_path_namespaceObject.join)(agentsDir, "valid-agent");
+            const invalidDir = (0, external_path_namespaceObject.join)(agentsDir, "invalid-agent");
+            (0, external_fs_namespaceObject.mkdirSync)(validDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.mkdirSync)(invalidDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(validDir, "agent.json"), JSON.stringify(validConfig));
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(invalidDir, "agent.json"), JSON.stringify(invalidConfig));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("valid-agent");
+        });
+        (0, external_vitest_namespaceObject.it)("should skip agents with invalid tool names", ()=>{
+            const agentConfig = {
+                name: "test-agent",
+                description: "Test agent with invalid tool",
+                systemPrompt: "You are a test agent",
+                tools: [
+                    "invalid_tool"
+                ]
+            };
+            const agentDir = (0, external_path_namespaceObject.join)(agentsDir, "test-agent");
+            (0, external_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(0);
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Agent with Model Override", ()=>{
+        (0, external_vitest_namespaceObject.it)("should support model override", ()=>{
+            const agentConfig = {
+                name: "custom-model-agent",
+                description: "Agent with custom model",
+                systemPrompt: "You are an agent with custom model",
+                model: "anthropic:claude-opus-4-5"
+            };
+            const agentDir = (0, external_path_namespaceObject.join)(agentsDir, "custom-model-agent");
+            (0, external_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("custom-model-agent");
+            (0, external_vitest_namespaceObject.expect)(agents[0].model).toBeDefined();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Subagent Loading", ()=>{
+        (0, external_vitest_namespaceObject.it)("should load agent with subagents", ()=>{
+            const agentConfig = {
+                name: "parent-agent",
+                description: "Parent agent with subagents",
+                systemPrompt: "You are a parent agent",
+                subagents: [
+                    {
+                        name: "subagent1",
+                        description: "First subagent",
+                        systemPrompt: "You are subagent 1",
+                        tools: [
+                            "think"
+                        ]
+                    },
+                    {
+                        name: "subagent2",
+                        description: "Second subagent",
+                        systemPrompt: "You are subagent 2",
+                        tools: [
+                            "internet_search"
+                        ]
+                    }
+                ]
+            };
+            const agentDir = (0, external_path_namespaceObject.join)(agentsDir, "parent-agent");
+            (0, external_fs_namespaceObject.mkdirSync)(agentDir, {
+                recursive: true
+            });
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toHaveLength(1);
+            (0, external_vitest_namespaceObject.expect)(agents[0].name).toBe("parent-agent");
+            (0, external_vitest_namespaceObject.expect)(agents[0].subAgents).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(agents[0].subAgents?.length).toBe(2);
+            (0, external_vitest_namespaceObject.expect)(agents[0].subAgents?.[0].name).toBe("subagent1");
+            (0, external_vitest_namespaceObject.expect)(agents[0].subAgents?.[1].name).toBe("subagent2");
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Empty Workspace", ()=>{
+        (0, external_vitest_namespaceObject.it)("should return empty array when no agents exist", ()=>{
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toEqual([]);
+        });
+        (0, external_vitest_namespaceObject.it)("should return empty array when agents directory doesn't exist", ()=>{
+            (0, external_fs_namespaceObject.rmSync)(agentsDir, {
+                recursive: true,
+                force: true
+            });
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            (0, external_vitest_namespaceObject.expect)(agents).toEqual([]);
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/integration/agent-invocation.integration.test.d.ts

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

package/dist/tests/integration/agent-invocation.integration.test.js

@@ -0,0 +1,258 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+describe("Agent Invocation Integration", ()=>{
+    let testDir;
+    let configDir;
+    let agentsDir;
+    beforeEach(()=>{
+        testDir = join(tmpdir(), `wingman-integration-${Date.now()}`);
+        configDir = join(testDir, ".wingman");
+        agentsDir = join(configDir, "agents");
+        mkdirSync(agentsDir, {
+            recursive: true
+        });
+    });
+    afterEach(()=>{
+        if (existsSync(testDir)) rmSync(testDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    describe("Agent Loading", ()=>{
+        it("should load agent with tools", ()=>{
+            const agentConfig = {
+                name: "test-agent",
+                description: "Test agent for integration testing",
+                systemPrompt: "You are a test agent",
+                tools: [
+                    "think",
+                    "internet_search"
+                ]
+            };
+            const agentDir = join(agentsDir, "test-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("test-agent");
+            expect(agents[0].tools).toEqual([
+                "think",
+                "internet_search"
+            ]);
+        });
+        it("should load multiple agents", ()=>{
+            const agent1Config = {
+                name: "agent1",
+                description: "First test agent",
+                systemPrompt: "You are agent 1",
+                tools: [
+                    "think"
+                ]
+            };
+            const agent2Config = {
+                name: "agent2",
+                description: "Second test agent",
+                systemPrompt: "You are agent 2",
+                tools: [
+                    "internet_search"
+                ]
+            };
+            const agent1Dir = join(agentsDir, "agent1");
+            const agent2Dir = join(agentsDir, "agent2");
+            mkdirSync(agent1Dir, {
+                recursive: true
+            });
+            mkdirSync(agent2Dir, {
+                recursive: true
+            });
+            writeFileSync(join(agent1Dir, "agent.json"), JSON.stringify(agent1Config));
+            writeFileSync(join(agent2Dir, "agent.json"), JSON.stringify(agent2Config));
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(2);
+            expect(agents.map((a)=>a.name)).toContain("agent1");
+            expect(agents.map((a)=>a.name)).toContain("agent2");
+        });
+        it("should create agent with command_execute tool and safety options", ()=>{
+            const agentConfig = {
+                name: "coder-agent",
+                description: "Agent with command execution",
+                systemPrompt: "You are a coding agent",
+                tools: [
+                    "command_execute"
+                ],
+                blockedCommands: [
+                    "rm",
+                    "sudo"
+                ],
+                allowScriptExecution: false,
+                commandTimeout: 30000
+            };
+            const agentDir = join(agentsDir, "coder-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("coder-agent");
+            expect(agents[0].tools).toEqual([
+                "command_execute"
+            ]);
+            expect(agents[0].blockedCommands).toEqual([
+                "rm",
+                "sudo"
+            ]);
+            expect(agents[0].allowScriptExecution).toBe(false);
+            expect(agents[0].commandTimeout).toBe(30000);
+        });
+        it("should find specific agent by name", async ()=>{
+            const agentConfig = {
+                name: "specific-agent",
+                description: "Specific test agent",
+                systemPrompt: "You are a specific agent"
+            };
+            const agentDir = join(agentsDir, "specific-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new AgentLoader(configDir, testDir);
+            const agent = await loader.loadAgent("specific-agent");
+            expect(agent).toBeDefined();
+            expect(agent?.name).toBe("specific-agent");
+        });
+        it("should return undefined for non-existent agent", async ()=>{
+            const loader = new AgentLoader(configDir, testDir);
+            const agent = await loader.loadAgent("non-existent-agent");
+            expect(agent).toBeUndefined();
+        });
+    });
+    describe("Agent Configuration Validation", ()=>{
+        it("should skip agents with invalid configuration", ()=>{
+            const validConfig = {
+                name: "valid-agent",
+                description: "Valid agent",
+                systemPrompt: "You are valid"
+            };
+            const invalidConfig = {
+                name: "invalid-agent"
+            };
+            const validDir = join(agentsDir, "valid-agent");
+            const invalidDir = join(agentsDir, "invalid-agent");
+            mkdirSync(validDir, {
+                recursive: true
+            });
+            mkdirSync(invalidDir, {
+                recursive: true
+            });
+            writeFileSync(join(validDir, "agent.json"), JSON.stringify(validConfig));
+            writeFileSync(join(invalidDir, "agent.json"), JSON.stringify(invalidConfig));
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("valid-agent");
+        });
+        it("should skip agents with invalid tool names", ()=>{
+            const agentConfig = {
+                name: "test-agent",
+                description: "Test agent with invalid tool",
+                systemPrompt: "You are a test agent",
+                tools: [
+                    "invalid_tool"
+                ]
+            };
+            const agentDir = join(agentsDir, "test-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(0);
+        });
+    });
+    describe("Agent with Model Override", ()=>{
+        it("should support model override", ()=>{
+            const agentConfig = {
+                name: "custom-model-agent",
+                description: "Agent with custom model",
+                systemPrompt: "You are an agent with custom model",
+                model: "anthropic:claude-opus-4-5"
+            };
+            const agentDir = join(agentsDir, "custom-model-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("custom-model-agent");
+            expect(agents[0].model).toBeDefined();
+        });
+    });
+    describe("Subagent Loading", ()=>{
+        it("should load agent with subagents", ()=>{
+            const agentConfig = {
+                name: "parent-agent",
+                description: "Parent agent with subagents",
+                systemPrompt: "You are a parent agent",
+                subagents: [
+                    {
+                        name: "subagent1",
+                        description: "First subagent",
+                        systemPrompt: "You are subagent 1",
+                        tools: [
+                            "think"
+                        ]
+                    },
+                    {
+                        name: "subagent2",
+                        description: "Second subagent",
+                        systemPrompt: "You are subagent 2",
+                        tools: [
+                            "internet_search"
+                        ]
+                    }
+                ]
+            };
+            const agentDir = join(agentsDir, "parent-agent");
+            mkdirSync(agentDir, {
+                recursive: true
+            });
+            writeFileSync(join(agentDir, "agent.json"), JSON.stringify(agentConfig));
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toHaveLength(1);
+            expect(agents[0].name).toBe("parent-agent");
+            expect(agents[0].subAgents).toBeDefined();
+            expect(agents[0].subAgents?.length).toBe(2);
+            expect(agents[0].subAgents?.[0].name).toBe("subagent1");
+            expect(agents[0].subAgents?.[1].name).toBe("subagent2");
+        });
+    });
+    describe("Empty Workspace", ()=>{
+        it("should return empty array when no agents exist", ()=>{
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toEqual([]);
+        });
+        it("should return empty array when agents directory doesn't exist", ()=>{
+            rmSync(agentsDir, {
+                recursive: true,
+                force: true
+            });
+            const loader = new AgentLoader(configDir, testDir);
+            const agents = loader.loadAllAgentConfigs();
+            expect(agents).toEqual([]);
+        });
+    });
+});

package/dist/tests/integration/finnhub-candles.integration.test.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const FINNHUB_BASE_URL = process.env.FINNHUB_BASE_URL?.trim() || "https://finnhub.io/api/v1";
+const FINNHUB_API_KEY = process.env.FINNHUB_API_KEY?.trim();
+const RUN_LIVE = "1" === process.env.FINNHUB_LIVE_TESTS;
+const describeLive = FINNHUB_API_KEY && RUN_LIVE ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
+const secondsPerDay = 86400;
+const buildCandleUrl = (scenario)=>{
+    const to = Math.floor(Date.now() / 1000);
+    const from = to - scenario.lookbackDays * secondsPerDay;
+    const url = new URL(`${FINNHUB_BASE_URL}/stock/candle`);
+    url.searchParams.set("symbol", scenario.symbol);
+    url.searchParams.set("resolution", scenario.resolution);
+    url.searchParams.set("from", String(from));
+    url.searchParams.set("to", String(to));
+    url.searchParams.set("token", FINNHUB_API_KEY || "");
+    return url.toString();
+};
+const scenarios = [
+    {
+        label: "daily-365",
+        symbol: "AAPL",
+        resolution: "D",
+        lookbackDays: 365
+    },
+    {
+        label: "daily-180",
+        symbol: "AAPL",
+        resolution: "D",
+        lookbackDays: 180
+    },
+    {
+        label: "daily-90",
+        symbol: "AAPL",
+        resolution: "D",
+        lookbackDays: 90
+    },
+    {
+        label: "hourly-180",
+        symbol: "AAPL",
+        resolution: "60",
+        lookbackDays: 180
+    },
+    {
+        label: "hourly-90",
+        symbol: "AAPL",
+        resolution: "60",
+        lookbackDays: 90
+    },
+    {
+        label: "hourly-30",
+        symbol: "AAPL",
+        resolution: "60",
+        lookbackDays: 30
+    },
+    {
+        label: "15m-30",
+        symbol: "AAPL",
+        resolution: "15",
+        lookbackDays: 30
+    },
+    {
+        label: "1m-7",
+        symbol: "AAPL",
+        resolution: "1",
+        lookbackDays: 7
+    }
+];
+describeLive("Finnhub candle access (live)", ()=>{
+    (0, external_vitest_namespaceObject.it)("does not return 403 for supported ranges", async ()=>{
+        const failures = [];
+        for (const scenario of scenarios){
+            const url = buildCandleUrl(scenario);
+            const response = await fetch(url, {
+                headers: {
+                    "User-Agent": "wingman-finnhub-test"
+                }
+            });
+            const body = await response.text();
+            console.info(`Finnhub candle ${scenario.label} -> ${response.status}`);
+            if (403 === response.status) {
+                failures.push(`403 for ${scenario.label} (${scenario.resolution}, ${scenario.lookbackDays}d): ${body.slice(0, 200)}`);
+                continue;
+            }
+            if (429 === response.status) {
+                console.warn(`Rate limited for ${scenario.label}; skipping assert.`);
+                continue;
+            }
+            (0, external_vitest_namespaceObject.expect)(response.status).toBe(200);
+        }
+        if (failures.length > 0) throw new Error(failures.join("\n"));
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/integration/finnhub-candles.integration.test.d.ts

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