@sweny-ai/core 0.1.0

package/dist/__tests__/claude.test.d.ts

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

package/dist/__tests__/claude.test.js

@@ -0,0 +1,328 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+// ─── tryParseJSON tests (via inlined copy since it's private) ────
+describe("JSON extraction strategies", () => {
+    function tryParseJSON(text) {
+        if (!text)
+            return {};
+        const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+        if (codeBlockMatch) {
+            try {
+                const parsed = JSON.parse(codeBlockMatch[1].trim());
+                if (typeof parsed === "object" && parsed !== null)
+                    return parsed;
+            }
+            catch {
+                /* try next */
+            }
+        }
+        const lastBrace = text.lastIndexOf("}");
+        if (lastBrace !== -1) {
+            let depth = 0;
+            for (let i = lastBrace; i >= 0; i--) {
+                if (text[i] === "}")
+                    depth++;
+                else if (text[i] === "{")
+                    depth--;
+                if (depth === 0) {
+                    try {
+                        const parsed = JSON.parse(text.slice(i, lastBrace + 1));
+                        if (typeof parsed === "object" && parsed !== null)
+                            return parsed;
+                    }
+                    catch {
+                        /* try next */
+                    }
+                    break;
+                }
+            }
+        }
+        try {
+            const parsed = JSON.parse(text.trim());
+            if (typeof parsed === "object" && parsed !== null)
+                return parsed;
+        }
+        catch {
+            /* fall through */
+        }
+        return {};
+    }
+    it("extracts JSON from code block", () => {
+        const text = 'Here are the results:\n```json\n{"severity": "high", "count": 42}\n```';
+        expect(tryParseJSON(text)).toEqual({ severity: "high", count: 42 });
+    });
+    it("extracts JSON from code block without json label", () => {
+        const text = 'Results:\n```\n{"ok": true}\n```';
+        expect(tryParseJSON(text)).toEqual({ ok: true });
+    });
+    it("extracts JSON from inline brace block", () => {
+        const text = 'The analysis is complete. {"result": "success", "items": [1,2,3]}';
+        expect(tryParseJSON(text)).toEqual({ result: "success", items: [1, 2, 3] });
+    });
+    it("extracts last JSON object when multiple exist", () => {
+        const text = 'First: {"a": 1}\nThen: {"b": 2}';
+        expect(tryParseJSON(text)).toEqual({ b: 2 });
+    });
+    it("handles nested JSON objects", () => {
+        const text = 'Output: {"outer": {"inner": true}}';
+        expect(tryParseJSON(text)).toEqual({ outer: { inner: true } });
+    });
+    it("parses pure JSON text", () => {
+        const text = '{"pure": "json"}';
+        expect(tryParseJSON(text)).toEqual({ pure: "json" });
+    });
+    it("returns empty object for no JSON", () => {
+        expect(tryParseJSON("No JSON here at all")).toEqual({});
+    });
+    it("returns empty object for invalid JSON", () => {
+        expect(tryParseJSON("{invalid json}")).toEqual({});
+    });
+    it("handles JSON with braces in strings", () => {
+        const text = '{"message": "use {curly} braces"}';
+        expect(tryParseJSON(text)).toEqual({ message: "use {curly} braces" });
+    });
+    it("handles multiline JSON in code block", () => {
+        const text = '```json\n{\n  "a": 1,\n  "b": {\n    "c": 2\n  }\n}\n```';
+        expect(tryParseJSON(text)).toEqual({ a: 1, b: { c: 2 } });
+    });
+    it("prefers code block over inline JSON", () => {
+        const text = '{"inline": true}\n```json\n{"codeblock": true}\n```';
+        expect(tryParseJSON(text)).toEqual({ codeblock: true });
+    });
+    it("handles empty code block gracefully", () => {
+        const text = '```json\n\n```\n{"fallback": true}';
+        expect(tryParseJSON(text)).toEqual({ fallback: true });
+    });
+});
+// ─── ClaudeClient tests ──────────────────────────────────────────
+// Mock the agent SDK to test ClaudeClient behavior
+describe("ClaudeClient", () => {
+    let mockQuery;
+    let mockCreateSdkMcpServer;
+    let mockSdkTool;
+    let ClaudeClient;
+    /** Helper: create an async generator that yields the given messages */
+    function makeStream(messages) {
+        return (async function* () {
+            for (const msg of messages) {
+                yield msg;
+            }
+        })();
+    }
+    beforeEach(async () => {
+        mockQuery = vi.fn();
+        mockCreateSdkMcpServer = vi.fn().mockReturnValue({ type: "sdk", name: "sweny-core" });
+        mockSdkTool = vi.fn().mockImplementation((name, desc, schema, handler) => ({
+            name,
+            description: desc,
+            inputSchema: schema,
+            handler,
+        }));
+        vi.doMock("@anthropic-ai/claude-agent-sdk", () => ({
+            query: mockQuery,
+            createSdkMcpServer: mockCreateSdkMcpServer,
+            tool: mockSdkTool,
+        }));
+        const mod = await import("../claude.js");
+        ClaudeClient = mod.ClaudeClient;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        vi.resetModules();
+    });
+    it("sends instruction and context in prompt", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: '{"done": true}' }]));
+        const client = new ClaudeClient();
+        await client.run({
+            instruction: "Analyze the logs",
+            context: { alert: "cpu spike" },
+            tools: [],
+        });
+        const callArgs = mockQuery.mock.calls[0][0];
+        expect(callArgs.prompt).toContain("Analyze the logs");
+        expect(callArgs.prompt).toContain("cpu spike");
+    });
+    it("passes system prompt and permissionMode", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "ok" }]));
+        const client = new ClaudeClient();
+        await client.run({ instruction: "x", context: {}, tools: [] });
+        const opts = mockQuery.mock.calls[0][0].options;
+        expect(opts.systemPrompt).toContain("automated workflow");
+        expect(opts.permissionMode).toBe("bypassPermissions");
+    });
+    it("returns success with parsed JSON data", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([
+            { type: "result", subtype: "success", result: 'Analysis complete.\n```json\n{"severity": "high"}\n```' },
+        ]));
+        const client = new ClaudeClient();
+        const result = await client.run({
+            instruction: "Check severity",
+            context: {},
+            tools: [],
+        });
+        expect(result.status).toBe("success");
+        expect(result.data.severity).toBe("high");
+    });
+    it("creates MCP server with converted tools", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "done" }]));
+        const handler = vi.fn().mockResolvedValue({ ok: true });
+        const client = new ClaudeClient();
+        await client.run({
+            instruction: "Do work",
+            context: {},
+            tools: [
+                {
+                    name: "my_tool",
+                    description: "A test tool",
+                    input_schema: {
+                        type: "object",
+                        properties: { query: { type: "string", description: "Search query" } },
+                        required: ["query"],
+                    },
+                    handler,
+                },
+            ],
+        });
+        // tool() was called for the tool
+        expect(mockSdkTool).toHaveBeenCalledOnce();
+        expect(mockSdkTool.mock.calls[0][0]).toBe("my_tool");
+        expect(mockSdkTool.mock.calls[0][1]).toBe("A test tool");
+        // MCP server was created
+        expect(mockCreateSdkMcpServer).toHaveBeenCalledOnce();
+        // mcpServers was passed to query
+        const opts = mockQuery.mock.calls[0][0].options;
+        expect(opts.mcpServers).toBeDefined();
+        expect(opts.mcpServers["sweny-core"]).toBeDefined();
+    });
+    it("does not create MCP server when no tools", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "done" }]));
+        const client = new ClaudeClient();
+        await client.run({ instruction: "x", context: {}, tools: [] });
+        const opts = mockQuery.mock.calls[0][0].options;
+        expect(opts.mcpServers).toBeUndefined();
+    });
+    it("tracks tool calls via handler wrapper", async () => {
+        // Simulate: query returns success, but the tool handler was invoked by MCP internally
+        // We test the handler wrapper directly since query is mocked
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "done" }]));
+        const handler = vi.fn().mockResolvedValue({ items: [1, 2] });
+        const client = new ClaudeClient();
+        const result = await client.run({
+            instruction: "x",
+            context: {},
+            tools: [{ name: "fetch_data", description: "d", input_schema: {}, handler }],
+        });
+        // The SDK tool handler was created — invoke it directly to test wrapping
+        const sdkHandler = mockSdkTool.mock.calls[0][3];
+        const callResult = await sdkHandler({ q: "test" }, {});
+        expect(callResult.content[0].text).toContain("items");
+        expect(callResult.isError).toBeUndefined();
+        // Tool call should be tracked
+        expect(result.toolCalls.length).toBeGreaterThanOrEqual(0); // stream didn't trigger it, but direct call did
+    });
+    it("wraps tool handler errors as isError", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "done" }]));
+        const handler = vi.fn().mockRejectedValue(new Error("tool broke"));
+        const client = new ClaudeClient();
+        await client.run({
+            instruction: "x",
+            context: {},
+            tools: [{ name: "bad_tool", description: "d", input_schema: {}, handler }],
+        });
+        // Invoke the SDK handler directly
+        const sdkHandler = mockSdkTool.mock.calls[0][3];
+        const callResult = await sdkHandler({}, {});
+        expect(callResult.content[0].text).toContain("tool broke");
+        expect(callResult.isError).toBe(true);
+    });
+    it("returns failed on query error", async () => {
+        mockQuery.mockReturnValueOnce((async function* () {
+            throw new Error("connection refused");
+        })());
+        const client = new ClaudeClient();
+        const result = await client.run({ instruction: "x", context: {}, tools: [] });
+        expect(result.status).toBe("failed");
+        expect(result.data.error).toContain("connection refused");
+    });
+    it("returns failed on error result subtype", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "error_max_turns", errors: ["Too many turns"], is_error: true }]));
+        const client = new ClaudeClient();
+        const result = await client.run({ instruction: "x", context: {}, tools: [] });
+        expect(result.status).toBe("failed");
+        expect(result.data.error).toContain("Too many turns");
+    });
+    it("passes model option to query", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "ok" }]));
+        const client = new ClaudeClient({ model: "claude-sonnet-4-20250514" });
+        await client.run({ instruction: "x", context: {}, tools: [] });
+        expect(mockQuery.mock.calls[0][0].options.model).toBe("claude-sonnet-4-20250514");
+    });
+    it("evaluate returns exact match", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "handle_high" }]));
+        const client = new ClaudeClient();
+        const result = await client.evaluate({
+            question: "Which path?",
+            context: {},
+            choices: [
+                { id: "handle_high", description: "High severity" },
+                { id: "handle_low", description: "Low severity" },
+            ],
+        });
+        expect(result).toBe("handle_high");
+    });
+    it("evaluate returns fuzzy match", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([
+            { type: "result", subtype: "success", result: "I think the answer is handle_low based on the data" },
+        ]));
+        const client = new ClaudeClient();
+        const result = await client.evaluate({
+            question: "Which path?",
+            context: {},
+            choices: [
+                { id: "handle_high", description: "High" },
+                { id: "handle_low", description: "Low" },
+            ],
+        });
+        expect(result).toBe("handle_low");
+    });
+    it("evaluate falls back to first choice", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: "I'm not sure" }]));
+        const client = new ClaudeClient();
+        const result = await client.evaluate({
+            question: "Which?",
+            context: {},
+            choices: [
+                { id: "a", description: "A" },
+                { id: "b", description: "B" },
+            ],
+        });
+        expect(result).toBe("a");
+    });
+    it("evaluate falls back on query error", async () => {
+        mockQuery.mockReturnValueOnce((async function* () {
+            throw new Error("offline");
+        })());
+        const client = new ClaudeClient();
+        const result = await client.evaluate({
+            question: "Which?",
+            context: {},
+            choices: [
+                { id: "fallback", description: "Fallback" },
+                { id: "other", description: "Other" },
+            ],
+        });
+        expect(result).toBe("fallback");
+    });
+    it("includes output schema in prompt when provided", async () => {
+        mockQuery.mockReturnValueOnce(makeStream([{ type: "result", subtype: "success", result: '{"severity": "high"}' }]));
+        const client = new ClaudeClient();
+        await client.run({
+            instruction: "Analyze",
+            context: {},
+            tools: [],
+            outputSchema: { type: "object", properties: { severity: { type: "string" } } },
+        });
+        const prompt = mockQuery.mock.calls[0][0].prompt;
+        expect(prompt).toContain("Required Output");
+        expect(prompt).toContain("severity");
+    });
+});

package/dist/__tests__/executor.test.d.ts

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

package/dist/__tests__/executor.test.js

@@ -0,0 +1,296 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import * as path from "node:path";
+import { tmpdir } from "node:os";
+import { execute } from "../executor.js";
+import { MockClaude, createFileSkill } from "../testing.js";
+import { createSkillMap } from "../skills/index.js";
+// ─── Fixtures ────────────────────────────────────────────────────
+const tmpBase = path.join(tmpdir(), "sweny-executor-test");
+function freshDir(name) {
+    const dir = path.join(tmpBase, `${name}-${Date.now()}`);
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+const linearWorkflow = {
+    id: "linear",
+    name: "Linear",
+    description: "A→B→C",
+    entry: "a",
+    nodes: {
+        a: { name: "A", instruction: "Do A", skills: ["filesystem"] },
+        b: { name: "B", instruction: "Do B", skills: ["filesystem"] },
+        c: { name: "C", instruction: "Do C", skills: ["filesystem"] },
+    },
+    edges: [
+        { from: "a", to: "b" },
+        { from: "b", to: "c" },
+    ],
+};
+const branchingWorkflow = {
+    id: "branching",
+    name: "Branching",
+    description: "A → B or C",
+    entry: "check",
+    nodes: {
+        check: { name: "Check", instruction: "Check severity", skills: [] },
+        high: { name: "High", instruction: "Handle high", skills: [] },
+        low: { name: "Low", instruction: "Handle low", skills: [] },
+    },
+    edges: [
+        { from: "check", to: "high", when: "severity is high" },
+        { from: "check", to: "low", when: "severity is low" },
+    ],
+};
+// ─── Tests ───────────────────────────────────────────────────────
+describe("executor", () => {
+    let outputDir;
+    beforeEach(() => {
+        outputDir = freshDir("exec");
+    });
+    it("executes a linear workflow end-to-end", async () => {
+        const fileSkill = createFileSkill(outputDir);
+        writeFileSync(path.join(outputDir, "input.json"), JSON.stringify({ alert: "test" }));
+        const claude = new MockClaude({
+            responses: {
+                a: {
+                    toolCalls: [{ tool: "fs_read_json", input: { path: "input.json" } }],
+                    data: { context: "loaded" },
+                },
+                b: { data: { processed: true } },
+                c: {
+                    toolCalls: [{ tool: "fs_write_json", input: { path: "out.json", data: { done: true } } }],
+                    data: { written: true },
+                },
+            },
+        });
+        const events = [];
+        const results = await execute(linearWorkflow, { alert: "test" }, {
+            skills: createSkillMap([fileSkill]),
+            claude,
+            observer: (e) => events.push(e),
+            config: {},
+        });
+        expect(results.size).toBe(3);
+        expect(results.get("a")?.status).toBe("success");
+        expect(results.get("b")?.status).toBe("success");
+        expect(results.get("c")?.status).toBe("success");
+        // Verify file was written
+        expect(existsSync(path.join(outputDir, "out.json"))).toBe(true);
+        // Events
+        expect(events[0]).toEqual({ type: "workflow:start", workflow: "linear" });
+        expect(events.filter((e) => e.type === "node:enter")).toHaveLength(3);
+        expect(events[events.length - 1].type).toBe("workflow:end");
+    });
+    it("executes conditional branches", async () => {
+        const claude = new MockClaude({
+            workflow: branchingWorkflow,
+            responses: {
+                check: { data: { severity: "high" } },
+                high: { data: { handled: true } },
+            },
+            routes: { check: "high" },
+        });
+        const results = await execute(branchingWorkflow, { alert: "cpu" }, {
+            skills: createSkillMap([]),
+            claude,
+            config: {},
+        });
+        expect(results.size).toBe(2);
+        expect(results.has("check")).toBe(true);
+        expect(results.has("high")).toBe(true);
+        expect(results.has("low")).toBe(false);
+    });
+    it("routes to alternative branch", async () => {
+        const claude = new MockClaude({
+            workflow: branchingWorkflow,
+            responses: {
+                check: { data: { severity: "low" } },
+                low: { data: { skipped: true } },
+            },
+            routes: { check: "low" },
+        });
+        const results = await execute(branchingWorkflow, { alert: "minor" }, {
+            skills: createSkillMap([]),
+            claude,
+            config: {},
+        });
+        expect(results.size).toBe(2);
+        expect(results.has("low")).toBe(true);
+        expect(results.has("high")).toBe(false);
+    });
+    it("emits tool:call and tool:result events", async () => {
+        const fileSkill = createFileSkill(outputDir);
+        writeFileSync(path.join(outputDir, "data.json"), '{"key": "value"}');
+        const claude = new MockClaude({
+            responses: {
+                a: {
+                    toolCalls: [{ tool: "fs_read_json", input: { path: "data.json" } }],
+                    data: { read: true },
+                },
+                b: { data: {} },
+                c: { data: {} },
+            },
+        });
+        const events = [];
+        await execute(linearWorkflow, {}, {
+            skills: createSkillMap([fileSkill]),
+            claude,
+            observer: (e) => events.push(e),
+            config: {},
+        });
+        const toolCalls = events.filter((e) => e.type === "tool:call");
+        const toolResults = events.filter((e) => e.type === "tool:result");
+        expect(toolCalls).toHaveLength(1);
+        expect(toolResults).toHaveLength(1);
+        expect(toolCalls[0]).toMatchObject({ type: "tool:call", node: "a", tool: "fs_read_json" });
+    });
+    it("observer errors do not crash the workflow", async () => {
+        const claude = new MockClaude({
+            responses: {
+                a: { data: {} },
+                b: { data: {} },
+                c: { data: {} },
+            },
+        });
+        const results = await execute(linearWorkflow, {}, {
+            skills: createSkillMap([]),
+            claude,
+            observer: () => {
+                throw new Error("observer boom");
+            },
+            config: {},
+        });
+        // Workflow completed despite observer throwing
+        expect(results.size).toBe(3);
+    });
+    it("throws on missing entry node", async () => {
+        const bad = { ...linearWorkflow, entry: "nonexistent" };
+        const claude = new MockClaude({ responses: {} });
+        await expect(execute(bad, {}, { skills: createSkillMap([]), claude, config: {} })).rejects.toThrow("Entry node");
+    });
+    it("throws on invalid edge reference", async () => {
+        const bad = {
+            ...linearWorkflow,
+            edges: [
+                { from: "a", to: "ghost" },
+                { from: "a", to: "b" },
+            ],
+        };
+        const claude = new MockClaude({ responses: {} });
+        await expect(execute(bad, {}, { skills: createSkillMap([]), claude, config: {} })).rejects.toThrow("unknown node");
+    });
+    it("handles single-node workflow (entry = terminal)", async () => {
+        const singleNode = {
+            id: "single",
+            name: "Single",
+            description: "",
+            entry: "only",
+            nodes: { only: { name: "Only", instruction: "Do it", skills: [] } },
+            edges: [],
+        };
+        const claude = new MockClaude({
+            responses: { only: { data: { result: "done" } } },
+        });
+        const results = await execute(singleNode, {}, {
+            skills: createSkillMap([]),
+            claude,
+            config: {},
+        });
+        expect(results.size).toBe(1);
+        expect(results.get("only")?.data.result).toBe("done");
+    });
+    it("passes prior node results as context", async () => {
+        let capturedContext = {};
+        const mockClaude = {
+            async run(opts) {
+                capturedContext = opts.context;
+                return { status: "success", data: { step: "done" }, toolCalls: [] };
+            },
+            async evaluate(opts) {
+                return opts.choices[0].id;
+            },
+        };
+        const twoStep = {
+            id: "two",
+            name: "Two",
+            description: "",
+            entry: "first",
+            nodes: {
+                first: { name: "First", instruction: "First step", skills: [] },
+                second: { name: "Second", instruction: "Second step", skills: [] },
+            },
+            edges: [{ from: "first", to: "second" }],
+        };
+        await execute(twoStep, { original: true }, {
+            skills: createSkillMap([]),
+            claude: mockClaude,
+            config: {},
+        });
+        // Second node should have first node's result in context
+        expect(capturedContext).toHaveProperty("first");
+        expect(capturedContext).toHaveProperty("input");
+    });
+    it("resolves config from env vars and overrides", async () => {
+        // This tests that config resolution works (skill with required config)
+        const skillWithConfig = {
+            id: "needs-config",
+            name: "Needs Config",
+            description: "test",
+            config: {
+                MY_KEY: { description: "A key", required: true, env: "MY_KEY_ENV" },
+            },
+            tools: [],
+        };
+        const claude = new MockClaude({
+            responses: { a: { data: {} }, b: { data: {} }, c: { data: {} } },
+        });
+        // Should throw without config
+        await expect(execute(linearWorkflow, {}, {
+            skills: createSkillMap([skillWithConfig]),
+            claude,
+        })).rejects.toThrow("Missing required config");
+        // Should succeed with override
+        const results = await execute(linearWorkflow, {}, {
+            skills: createSkillMap([skillWithConfig]),
+            claude,
+            config: { MY_KEY: "provided" },
+        });
+        expect(results.size).toBe(3);
+    });
+    it("handles failed node results", async () => {
+        const claude = new MockClaude({
+            responses: {
+                a: { status: "failed", data: { error: "something broke" } },
+                b: { data: {} },
+                c: { data: {} },
+            },
+        });
+        const results = await execute(linearWorkflow, {}, {
+            skills: createSkillMap([]),
+            claude,
+            config: {},
+        });
+        // All nodes still execute (executor doesn't short-circuit on failure)
+        expect(results.get("a")?.status).toBe("failed");
+    });
+    it("validates route choice falls back on invalid Claude response", async () => {
+        // Create a claude mock that returns an invalid route
+        const badRouteClaude = {
+            async run() {
+                return { status: "success", data: {}, toolCalls: [] };
+            },
+            async evaluate() {
+                return "nonexistent_node"; // invalid target
+            },
+        };
+        const results = await execute(branchingWorkflow, {}, {
+            skills: createSkillMap([]),
+            claude: badRouteClaude,
+            config: {},
+        });
+        // Should still complete — falls back to first valid edge target
+        expect(results.size).toBe(2);
+    });
+});

package/dist/__tests__/integration/datadog.integration.test.d.ts

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

package/dist/__tests__/integration/datadog.integration.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "vitest";
+import { available } from "./harness.js";
+import { datadog } from "../../skills/datadog.js";
+const ctx = () => ({
+    config: {
+        DD_API_KEY: process.env.DD_API_KEY,
+        DD_APP_KEY: process.env.DD_APP_KEY,
+        DD_SITE: process.env.DD_SITE ?? "",
+    },
+    logger: console,
+});
+describe.runIf(available.datadog)("datadog integration", () => {
+    it("lists monitors", async () => {
+        const tool = datadog.tools.find((t) => t.name === "datadog_list_monitors");
+        const result = await tool.handler({}, ctx());
+        expect(Array.isArray(result)).toBe(true);
+    }, 15_000);
+    it("searches logs", async () => {
+        const tool = datadog.tools.find((t) => t.name === "datadog_search_logs");
+        const result = await tool.handler({ query: "*", from: "now-5m", limit: 5 }, ctx());
+        expect(result).toHaveProperty("data");
+    }, 15_000);
+});

package/dist/__tests__/integration/e2e-workflow.integration.test.d.ts

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