@wingman-ai/gateway 0.1.5 → 0.2.0

package/dist/tests/agents-api.test.cjs

@@ -0,0 +1,232 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const agents_cjs_namespaceObject = require("../gateway/http/agents.cjs");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_os_namespaceObject = require("node:os");
+const external_js_yaml_namespaceObject = require("js-yaml");
+const isBunRuntime = void 0 !== globalThis.Bun;
+const describeIfBun = isBunRuntime ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
+const parseMarkdownAgent = (raw)=>{
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+    const match = raw.match(frontmatterRegex);
+    if (!match) throw new Error("Agent markdown is missing frontmatter");
+    const metadata = external_js_yaml_namespaceObject.load(match[1]) || {};
+    return {
+        metadata,
+        prompt: match[2].trim()
+    };
+};
+describeIfBun("agents API", ()=>{
+    let tempDir;
+    let config;
+    let ctx;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-agents-api-"));
+        config = {
+            agents: {
+                list: [],
+                bindings: []
+            }
+        };
+        ctx = {
+            workspace: tempDir,
+            configDir: tempDir,
+            getWingmanConfig: ()=>config,
+            setWingmanConfig: (next)=>{
+                config = next;
+            },
+            persistWingmanConfig: ()=>{},
+            router: {},
+            setRouter: ()=>{},
+            resolveConfigDirPath: ()=>tempDir,
+            getBuiltInTools: ()=>[]
+        };
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        (0, external_node_fs_namespaceObject.rmSync)(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("creates agent markdown with promptTraining and subAgents", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "orchestrator",
+                displayName: "Orchestrator",
+                description: "Delegates work",
+                tools: [
+                    "think",
+                    "not_real_tool"
+                ],
+                prompt: "You are the orchestrator.",
+                promptTraining: {
+                    enabled: true,
+                    instructionsPath: "/memories/agents/orchestrator/instructions.md"
+                },
+                subAgents: [
+                    {
+                        id: "planner",
+                        description: "Plans tasks",
+                        tools: [
+                            "think",
+                            "not_real_tool"
+                        ],
+                        prompt: "Plan tasks in detail.",
+                        promptTraining: true
+                    },
+                    {
+                        id: "executor",
+                        description: "Executes tasks",
+                        tools: [
+                            "command_execute"
+                        ],
+                        prompt: "Execute planned tasks."
+                    }
+                ]
+            })
+        });
+        const createRes = await (0, agents_cjs_namespaceObject.handleAgentsApi)(ctx, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        (0, external_vitest_namespaceObject.expect)(created.promptTraining).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/agents/orchestrator/instructions.md"
+        });
+        (0, external_vitest_namespaceObject.expect)(created.promptRefinement).toEqual(created.promptTraining);
+        (0, external_vitest_namespaceObject.expect)(created.subAgents).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(created.subAgents[0].promptTraining).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(created.subAgents[0].tools).toEqual([
+            "think"
+        ]);
+        const agentPath = (0, external_node_path_namespaceObject.join)(tempDir, "agents", "orchestrator", "agent.md");
+        const parsed = parseMarkdownAgent((0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8"));
+        (0, external_vitest_namespaceObject.expect)(parsed.prompt).toBe("You are the orchestrator.");
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.promptRefinement).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/agents/orchestrator/instructions.md"
+        });
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].name).toBe("planner");
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].promptRefinement).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].systemPrompt).toBe("Plan tasks in detail.");
+        const detailReq = new Request("http://localhost/api/agents/orchestrator", {
+            method: "GET"
+        });
+        const detailRes = await (0, agents_cjs_namespaceObject.handleAgentsApi)(ctx, detailReq, new URL(detailReq.url));
+        (0, external_vitest_namespaceObject.expect)(detailRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(detailRes?.ok).toBe(true);
+        const detail = await detailRes.json();
+        (0, external_vitest_namespaceObject.expect)(detail.promptTraining).toEqual(created.promptTraining);
+        (0, external_vitest_namespaceObject.expect)(detail.promptRefinement).toEqual(created.promptTraining);
+        (0, external_vitest_namespaceObject.expect)(detail.subAgents).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(detail.subAgents[0].id).toBe("planner");
+        (0, external_vitest_namespaceObject.expect)(detail.subAgents[0].prompt).toBe("Plan tasks in detail.");
+    });
+    (0, external_vitest_namespaceObject.it)("updates promptTraining and subAgents in markdown", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "editor-agent",
+                tools: [
+                    "think"
+                ],
+                prompt: "Original prompt",
+                promptTraining: true,
+                subAgents: [
+                    {
+                        id: "planner",
+                        description: "Plans",
+                        tools: [
+                            "think"
+                        ],
+                        prompt: "Original planner prompt"
+                    }
+                ]
+            })
+        });
+        const createRes = await (0, agents_cjs_namespaceObject.handleAgentsApi)(ctx, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const updateReq = new Request("http://localhost/api/agents/editor-agent", {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                promptTraining: false,
+                subAgents: [
+                    {
+                        id: "reviewer",
+                        description: "Reviews output",
+                        tools: [
+                            "git_status"
+                        ],
+                        prompt: "Review carefully.",
+                        promptTraining: {
+                            enabled: true,
+                            instructionsPath: "/memories/reviewer.md"
+                        }
+                    }
+                ]
+            })
+        });
+        const updateRes = await (0, agents_cjs_namespaceObject.handleAgentsApi)(ctx, updateReq, new URL(updateReq.url));
+        (0, external_vitest_namespaceObject.expect)(updateRes).not.toBeNull();
+        if (updateRes && !updateRes.ok) throw new Error(await updateRes.text());
+        (0, external_vitest_namespaceObject.expect)(updateRes?.ok).toBe(true);
+        const updated = await updateRes.json();
+        (0, external_vitest_namespaceObject.expect)(updated.promptTraining).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(updated.promptRefinement).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(updated.subAgents).toHaveLength(1);
+        (0, external_vitest_namespaceObject.expect)(updated.subAgents[0].id).toBe("reviewer");
+        (0, external_vitest_namespaceObject.expect)(updated.subAgents[0].promptTraining).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/reviewer.md"
+        });
+        const agentPath = (0, external_node_path_namespaceObject.join)(tempDir, "agents", "editor-agent", "agent.md");
+        const parsed = parseMarkdownAgent((0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8"));
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.promptRefinement).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents).toHaveLength(1);
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].name).toBe("reviewer");
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].promptRefinement).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/reviewer.md"
+        });
+        (0, external_vitest_namespaceObject.expect)(parsed.metadata.subAgents[0].systemPrompt).toBe("Review carefully.");
+    });
+    (0, external_vitest_namespaceObject.it)("accepts legacy promptRefinement input as promptTraining", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "legacy-agent",
+                tools: [
+                    "think"
+                ],
+                prompt: "Legacy prompt",
+                promptRefinement: true
+            })
+        });
+        const createRes = await (0, agents_cjs_namespaceObject.handleAgentsApi)(ctx, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        (0, external_vitest_namespaceObject.expect)(created.promptTraining).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(created.promptRefinement).toBe(true);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/agents-api.test.d.ts

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

package/dist/tests/agents-api.test.js

@@ -0,0 +1,226 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { handleAgentsApi } from "../gateway/http/agents.js";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { load } from "js-yaml";
+const isBunRuntime = void 0 !== globalThis.Bun;
+const describeIfBun = isBunRuntime ? describe : describe.skip;
+const parseMarkdownAgent = (raw)=>{
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+    const match = raw.match(frontmatterRegex);
+    if (!match) throw new Error("Agent markdown is missing frontmatter");
+    const metadata = load(match[1]) || {};
+    return {
+        metadata,
+        prompt: match[2].trim()
+    };
+};
+describeIfBun("agents API", ()=>{
+    let tempDir;
+    let config;
+    let ctx;
+    beforeEach(()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-agents-api-"));
+        config = {
+            agents: {
+                list: [],
+                bindings: []
+            }
+        };
+        ctx = {
+            workspace: tempDir,
+            configDir: tempDir,
+            getWingmanConfig: ()=>config,
+            setWingmanConfig: (next)=>{
+                config = next;
+            },
+            persistWingmanConfig: ()=>{},
+            router: {},
+            setRouter: ()=>{},
+            resolveConfigDirPath: ()=>tempDir,
+            getBuiltInTools: ()=>[]
+        };
+    });
+    afterEach(()=>{
+        rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("creates agent markdown with promptTraining and subAgents", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "orchestrator",
+                displayName: "Orchestrator",
+                description: "Delegates work",
+                tools: [
+                    "think",
+                    "not_real_tool"
+                ],
+                prompt: "You are the orchestrator.",
+                promptTraining: {
+                    enabled: true,
+                    instructionsPath: "/memories/agents/orchestrator/instructions.md"
+                },
+                subAgents: [
+                    {
+                        id: "planner",
+                        description: "Plans tasks",
+                        tools: [
+                            "think",
+                            "not_real_tool"
+                        ],
+                        prompt: "Plan tasks in detail.",
+                        promptTraining: true
+                    },
+                    {
+                        id: "executor",
+                        description: "Executes tasks",
+                        tools: [
+                            "command_execute"
+                        ],
+                        prompt: "Execute planned tasks."
+                    }
+                ]
+            })
+        });
+        const createRes = await handleAgentsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        expect(created.promptTraining).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/agents/orchestrator/instructions.md"
+        });
+        expect(created.promptRefinement).toEqual(created.promptTraining);
+        expect(created.subAgents).toHaveLength(2);
+        expect(created.subAgents[0].promptTraining).toBe(true);
+        expect(created.subAgents[0].tools).toEqual([
+            "think"
+        ]);
+        const agentPath = join(tempDir, "agents", "orchestrator", "agent.md");
+        const parsed = parseMarkdownAgent(readFileSync(agentPath, "utf-8"));
+        expect(parsed.prompt).toBe("You are the orchestrator.");
+        expect(parsed.metadata.promptRefinement).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/agents/orchestrator/instructions.md"
+        });
+        expect(parsed.metadata.subAgents).toHaveLength(2);
+        expect(parsed.metadata.subAgents[0].name).toBe("planner");
+        expect(parsed.metadata.subAgents[0].promptRefinement).toBe(true);
+        expect(parsed.metadata.subAgents[0].systemPrompt).toBe("Plan tasks in detail.");
+        const detailReq = new Request("http://localhost/api/agents/orchestrator", {
+            method: "GET"
+        });
+        const detailRes = await handleAgentsApi(ctx, detailReq, new URL(detailReq.url));
+        expect(detailRes).not.toBeNull();
+        expect(detailRes?.ok).toBe(true);
+        const detail = await detailRes.json();
+        expect(detail.promptTraining).toEqual(created.promptTraining);
+        expect(detail.promptRefinement).toEqual(created.promptTraining);
+        expect(detail.subAgents).toHaveLength(2);
+        expect(detail.subAgents[0].id).toBe("planner");
+        expect(detail.subAgents[0].prompt).toBe("Plan tasks in detail.");
+    });
+    it("updates promptTraining and subAgents in markdown", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "editor-agent",
+                tools: [
+                    "think"
+                ],
+                prompt: "Original prompt",
+                promptTraining: true,
+                subAgents: [
+                    {
+                        id: "planner",
+                        description: "Plans",
+                        tools: [
+                            "think"
+                        ],
+                        prompt: "Original planner prompt"
+                    }
+                ]
+            })
+        });
+        const createRes = await handleAgentsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes?.ok).toBe(true);
+        const updateReq = new Request("http://localhost/api/agents/editor-agent", {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                promptTraining: false,
+                subAgents: [
+                    {
+                        id: "reviewer",
+                        description: "Reviews output",
+                        tools: [
+                            "git_status"
+                        ],
+                        prompt: "Review carefully.",
+                        promptTraining: {
+                            enabled: true,
+                            instructionsPath: "/memories/reviewer.md"
+                        }
+                    }
+                ]
+            })
+        });
+        const updateRes = await handleAgentsApi(ctx, updateReq, new URL(updateReq.url));
+        expect(updateRes).not.toBeNull();
+        if (updateRes && !updateRes.ok) throw new Error(await updateRes.text());
+        expect(updateRes?.ok).toBe(true);
+        const updated = await updateRes.json();
+        expect(updated.promptTraining).toBe(false);
+        expect(updated.promptRefinement).toBe(false);
+        expect(updated.subAgents).toHaveLength(1);
+        expect(updated.subAgents[0].id).toBe("reviewer");
+        expect(updated.subAgents[0].promptTraining).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/reviewer.md"
+        });
+        const agentPath = join(tempDir, "agents", "editor-agent", "agent.md");
+        const parsed = parseMarkdownAgent(readFileSync(agentPath, "utf-8"));
+        expect(parsed.metadata.promptRefinement).toBe(false);
+        expect(parsed.metadata.subAgents).toHaveLength(1);
+        expect(parsed.metadata.subAgents[0].name).toBe("reviewer");
+        expect(parsed.metadata.subAgents[0].promptRefinement).toEqual({
+            enabled: true,
+            instructionsPath: "/memories/reviewer.md"
+        });
+        expect(parsed.metadata.subAgents[0].systemPrompt).toBe("Review carefully.");
+    });
+    it("accepts legacy promptRefinement input as promptTraining", async ()=>{
+        const createReq = new Request("http://localhost/api/agents", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                id: "legacy-agent",
+                tools: [
+                    "think"
+                ],
+                prompt: "Legacy prompt",
+                promptRefinement: true
+            })
+        });
+        const createRes = await handleAgentsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        expect(created.promptTraining).toBe(true);
+        expect(created.promptRefinement).toBe(true);
+    });
+});

package/dist/tests/gateway.test.cjs

@@ -275,6 +275,27 @@ describeIfBun("Gateway", ()=>{
         webuiClient.close();
         requester.close();
     });
+    (0, external_vitest_namespaceObject.it)("should broadcast user messages to desktop clients without session subscribe", async ()=>{
+        const desktopClient = await connectClient("session-desktop-listener", "desktop");
+        const requester = await connectClient("session-desktop-requester");
+        const sessionId = "session-desktop-test";
+        const eventPromise = waitForMessage(desktopClient, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user" && msg.payload?.sessionId === sessionId);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: "req-session-desktop",
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Hello desktop"
+            },
+            timestamp: Date.now()
+        }));
+        const eventMsg = await eventPromise;
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.content).toBe("Hello desktop");
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.agentId).toBe("main");
+        desktopClient.close();
+        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",

package/dist/tests/gateway.test.js

@@ -273,6 +273,27 @@ describeIfBun("Gateway", ()=>{
         webuiClient.close();
         requester.close();
     });
+    it("should broadcast user messages to desktop clients without session subscribe", async ()=>{
+        const desktopClient = await connectClient("session-desktop-listener", "desktop");
+        const requester = await connectClient("session-desktop-requester");
+        const sessionId = "session-desktop-test";
+        const eventPromise = waitForMessage(desktopClient, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user" && msg.payload?.sessionId === sessionId);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: "req-session-desktop",
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Hello desktop"
+            },
+            timestamp: Date.now()
+        }));
+        const eventMsg = await eventPromise;
+        expect(eventMsg.payload?.content).toBe("Hello desktop");
+        expect(eventMsg.payload?.agentId).toBe("main");
+        desktopClient.close();
+        requester.close();
+    });
     it("should clear session messages via API", async ()=>{
         const createRes = await fetch(`http://localhost:${port}/api/sessions`, {
             method: "POST",

package/dist/tests/sessionMessageAttachments.test.cjs

@@ -101,6 +101,65 @@ const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.c
             }
         ]);
     });
+    (0, external_vitest_namespaceObject.it)("extracts standardized base64 file blocks", ()=>{
+        const blocks = [
+            {
+                type: "file",
+                source_type: "base64",
+                data: "JVBERi0xLjQK",
+                mime_type: "application/pdf",
+                metadata: {
+                    filename: "report.pdf"
+                }
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractAttachments)(blocks)).toEqual([
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "report.pdf",
+                mimeType: "application/pdf"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("extracts input_file blocks", ()=>{
+        const blocks = [
+            {
+                type: "input_file",
+                file_data: "data:application/pdf;base64,JVBERi0xLjQK",
+                filename: "invoice.pdf"
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractAttachments)(blocks)).toEqual([
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "invoice.pdf",
+                mimeType: "application/pdf"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("extracts anthropic document blocks", ()=>{
+        const blocks = [
+            {
+                type: "document",
+                title: "scan.pdf",
+                source: {
+                    type: "base64",
+                    media_type: "application/pdf",
+                    data: "JVBERi0xLjQK"
+                }
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractAttachments)(blocks)).toEqual([
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "scan.pdf",
+                mimeType: "application/pdf"
+            }
+        ]);
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/sessionMessageAttachments.test.js

@@ -99,4 +99,63 @@ describe("extractAttachments", ()=>{
             }
         ]);
     });
+    it("extracts standardized base64 file blocks", ()=>{
+        const blocks = [
+            {
+                type: "file",
+                source_type: "base64",
+                data: "JVBERi0xLjQK",
+                mime_type: "application/pdf",
+                metadata: {
+                    filename: "report.pdf"
+                }
+            }
+        ];
+        expect(extractAttachments(blocks)).toEqual([
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "report.pdf",
+                mimeType: "application/pdf"
+            }
+        ]);
+    });
+    it("extracts input_file blocks", ()=>{
+        const blocks = [
+            {
+                type: "input_file",
+                file_data: "data:application/pdf;base64,JVBERi0xLjQK",
+                filename: "invoice.pdf"
+            }
+        ];
+        expect(extractAttachments(blocks)).toEqual([
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "invoice.pdf",
+                mimeType: "application/pdf"
+            }
+        ]);
+    });
+    it("extracts anthropic document blocks", ()=>{
+        const blocks = [
+            {
+                type: "document",
+                title: "scan.pdf",
+                source: {
+                    type: "base64",
+                    media_type: "application/pdf",
+                    data: "JVBERi0xLjQK"
+                }
+            }
+        ];
+        expect(extractAttachments(blocks)).toEqual([
+            {
+                kind: "file",
+                dataUrl: "data:application/pdf;base64,JVBERi0xLjQK",
+                name: "scan.pdf",
+                mimeType: "application/pdf"
+            }
+        ]);
+    });
 });

package/dist/types/agents.d.ts

@@ -7,6 +7,10 @@ export type WingmanAgentTool = {
     schema?: unknown;
     invoke?: (...args: any[]) => unknown;
 };
+export type PromptRefinementConfig = {
+    enabled?: boolean;
+    instructionsPath?: string;
+};
 export type WingmanAgent = {
     name: string;
     systemPrompt: string;
@@ -19,4 +23,5 @@ export type WingmanAgent = {
     mcpConfig?: MCPServersConfig;
     mcpUseGlobal?: boolean;
     voice?: AgentVoiceConfig;
+    promptRefinement?: PromptRefinementConfig;
 };