@agentapplicationprotocol/server 0.4.1 → 0.5.0

package/dist/src/server.test.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const hono_1 = require("hono");
+const bearer_auth_1 = require("hono/bearer-auth");
+const cors_1 = require("hono/cors");
+const server_1 = require("./server");
+const meta = { version: 1, agents: [] };
+const session = { sessionId: "s1", agent: { name: "a" } };
+const agentResponse = { stopReason: "end_turn", messages: [] };
+const createSessionResponse = { ...agentResponse, sessionId: "s1" };
+const sessionList = { sessions: ["s1"] };
+async function* sseEvents() {
+    yield { event: "turn_start" };
+    yield { event: "text", text: "hi" };
+    yield { event: "turn_stop", stopReason: "end_turn" };
+}
+function makeHandler(overrides = {}) {
+    return {
+        getMeta: vitest_1.vi.fn().mockReturnValue(meta),
+        listSessions: vitest_1.vi.fn().mockResolvedValue(sessionList),
+        getSession: vitest_1.vi.fn().mockResolvedValue(session),
+        createSession: vitest_1.vi.fn().mockResolvedValue(createSessionResponse),
+        sendTurn: vitest_1.vi.fn().mockResolvedValue(agentResponse),
+        deleteSession: vitest_1.vi.fn().mockResolvedValue(undefined),
+        ...overrides,
+    };
+}
+function makeApp(handler, setup) {
+    const app = new hono_1.Hono();
+    setup?.(app);
+    app.route("/", (0, server_1.aap)(handler));
+    return app;
+}
+function req(method, path, body, headers) {
+    return new Request(`http://localhost${path}`, {
+        method,
+        headers: { "Content-Type": "application/json", ...headers },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+}
+(0, vitest_1.describe)("aap middleware", () => {
+    (0, vitest_1.it)("GET /meta returns meta", async () => {
+        const app = makeApp(makeHandler());
+        const res = await app.fetch(req("GET", "/meta"));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual(meta);
+    });
+    (0, vitest_1.it)("GET /session/:id returns session", async () => {
+        const app = makeApp(makeHandler());
+        const res = await app.fetch(req("GET", "/session/s1"));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual(session);
+    });
+    (0, vitest_1.it)("GET /session/:id redacts secret options", async () => {
+        const secretSession = {
+            sessionId: "s1",
+            agent: { name: "a", options: { key: "mysecret", model: "gpt-4" } },
+        };
+        const secretMeta = {
+            version: 1,
+            agents: [
+                {
+                    name: "a",
+                    version: "1.0.0",
+                    options: [
+                        { type: "secret", name: "key", default: "" },
+                        { type: "text", name: "model", default: "" },
+                    ],
+                },
+            ],
+        };
+        const app = makeApp(makeHandler({
+            getSession: vitest_1.vi.fn().mockResolvedValue(secretSession),
+            getMeta: vitest_1.vi.fn().mockReturnValue(secretMeta),
+        }));
+        const res = await app.fetch(req("GET", "/session/s1"));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual({
+            ...secretSession,
+            agent: { ...secretSession.agent, options: { key: "***", model: "gpt-4" } },
+        });
+    });
+    (0, vitest_1.it)("GET /sessions returns session list", async () => {
+        const handler = makeHandler();
+        const app = makeApp(handler);
+        const res = await app.fetch(req("GET", "/sessions?after=cursor1"));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual(sessionList);
+        (0, vitest_1.expect)(handler.listSessions).toHaveBeenCalledWith({ after: "cursor1" });
+    });
+    (0, vitest_1.it)("PUT /session returns 400 if last message is not a user message", async () => {
+        const app = makeApp(makeHandler());
+        const res = await app.fetch(req("PUT", "/session", {
+            agent: { name: "a" },
+            messages: [{ role: "assistant", content: "hi" }],
+        }));
+        (0, vitest_1.expect)(res.status).toBe(400);
+    });
+    (0, vitest_1.it)("PUT /session returns 201 with AgentResponse", async () => {
+        const app = makeApp(makeHandler());
+        const res = await app.fetch(req("PUT", "/session", { agent: { name: "a" }, messages: [{ role: "user", content: "hi" }] }));
+        (0, vitest_1.expect)(res.status).toBe(201);
+        (0, vitest_1.expect)(await res.json()).toEqual(createSessionResponse);
+    });
+    (0, vitest_1.it)("PUT /session with stream returns SSE", async () => {
+        const app = makeApp(makeHandler({ createSession: vitest_1.vi.fn().mockResolvedValue(sseEvents()) }));
+        const res = await app.fetch(req("PUT", "/session", {
+            agent: { name: "a" },
+            messages: [{ role: "user", content: "hi" }],
+            stream: "message",
+        }));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(res.headers.get("content-type")).toContain("text/event-stream");
+    });
+    (0, vitest_1.it)("POST /session/:id returns AgentResponse", async () => {
+        const app = makeApp(makeHandler());
+        const res = await app.fetch(req("POST", "/session/s1", { messages: [{ role: "user", content: "hi" }] }));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual(agentResponse);
+    });
+    (0, vitest_1.it)("POST /session/:id with stream returns SSE", async () => {
+        const app = makeApp(makeHandler({ sendTurn: vitest_1.vi.fn().mockResolvedValue(sseEvents()) }));
+        const res = await app.fetch(req("POST", "/session/s1", { messages: [{ role: "user", content: "hi" }], stream: "delta" }));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(res.headers.get("content-type")).toContain("text/event-stream");
+    });
+    (0, vitest_1.it)("DELETE /session/:id returns 204", async () => {
+        const app = makeApp(makeHandler());
+        const res = await app.fetch(req("DELETE", "/session/s1"));
+        (0, vitest_1.expect)(res.status).toBe(204);
+    });
+    (0, vitest_1.it)("auth middleware: returns 401 when rejected", async () => {
+        const app = makeApp(makeHandler(), (a) => a.use((0, bearer_auth_1.bearerAuth)({ token: "secret" })));
+        const res = await app.fetch(req("GET", "/meta"));
+        (0, vitest_1.expect)(res.status).toBe(401);
+    });
+    (0, vitest_1.it)("auth middleware: passes with valid token", async () => {
+        const app = makeApp(makeHandler(), (a) => a.use((0, bearer_auth_1.bearerAuth)({ token: "secret" })));
+        const res = await app.fetch(req("GET", "/meta", undefined, { Authorization: "Bearer secret" }));
+        (0, vitest_1.expect)(res.status).toBe(200);
+    });
+    (0, vitest_1.it)("base path: mounts under sub-router", async () => {
+        const app = new hono_1.Hono();
+        app.route("/api/v1", (0, server_1.aap)(makeHandler()));
+        const res = await app.fetch(req("GET", "/api/v1/meta"));
+        (0, vitest_1.expect)(res.status).toBe(200);
+    });
+    (0, vitest_1.it)("cors: sets Access-Control-Allow-Origin header", async () => {
+        const app = makeApp(makeHandler(), (a) => a.use((0, cors_1.cors)({ origin: "https://example.com" })));
+        const res = await app.fetch(req("GET", "/meta", undefined, { Origin: "https://example.com" }));
+        (0, vitest_1.expect)(res.headers.get("access-control-allow-origin")).toBe("https://example.com");
+    });
+    (0, vitest_1.it)("GET /session/:id does not redact when agent not found in meta", async () => {
+        const sessionWithOptions = {
+            sessionId: "s1",
+            agent: { name: "unknown", options: { key: "secret" } },
+        };
+        const app = makeApp(makeHandler({
+            getSession: vitest_1.vi.fn().mockResolvedValue(sessionWithOptions),
+            getMeta: vitest_1.vi.fn().mockReturnValue({ version: 1, agents: [] }),
+        }));
+        const res = await app.fetch(req("GET", "/session/s1"));
+        (0, vitest_1.expect)(await res.json()).toEqual(sessionWithOptions);
+    });
+    (0, vitest_1.it)("GET /session/:id does not redact when agent has no secret options", async () => {
+        const sessionWithOptions = {
+            sessionId: "s1",
+            agent: { name: "a", options: { model: "gpt-4" } },
+        };
+        const app = makeApp(makeHandler({
+            getSession: vitest_1.vi.fn().mockResolvedValue(sessionWithOptions),
+            getMeta: vitest_1.vi.fn().mockReturnValue({
+                version: 1,
+                agents: [
+                    {
+                        name: "a",
+                        version: "1.0.0",
+                        options: [{ type: "text", name: "model", default: "" }],
+                    },
+                ],
+            }),
+        }));
+        const res = await app.fetch(req("GET", "/session/s1"));
+        (0, vitest_1.expect)(await res.json()).toEqual(sessionWithOptions);
+    });
+    (0, vitest_1.it)("GET /session/:id?history=compacted passes param and strips full", async () => {
+        const handler = makeHandler({
+            getSession: vitest_1.vi.fn().mockResolvedValue({
+                ...session,
+                history: { compacted: [], full: [] },
+            }),
+        });
+        const app = makeApp(handler);
+        const res = await app.fetch(req("GET", "/session/s1?history=compacted"));
+        (0, vitest_1.expect)(handler.getSession).toHaveBeenCalledWith("s1", "compacted");
+        (0, vitest_1.expect)(await res.json()).toEqual({ ...session, history: { compacted: [] } });
+    });
+    (0, vitest_1.it)("GET /session/:id?history=full passes param and strips compacted", async () => {
+        const handler = makeHandler({
+            getSession: vitest_1.vi.fn().mockResolvedValue({
+                ...session,
+                history: { compacted: [], full: [] },
+            }),
+        });
+        const app = makeApp(handler);
+        const res = await app.fetch(req("GET", "/session/s1?history=full"));
+        (0, vitest_1.expect)(handler.getSession).toHaveBeenCalledWith("s1", "full");
+        (0, vitest_1.expect)(await res.json()).toEqual({ ...session, history: { full: [] } });
+    });
+    (0, vitest_1.it)("GET /session/:id without ?history passes undefined and strips history from response", async () => {
+        const handler = makeHandler({
+            getSession: vitest_1.vi.fn().mockResolvedValue({
+                ...session,
+                history: { compacted: [], full: [] },
+            }),
+        });
+        const app = makeApp(handler);
+        const res = await app.fetch(req("GET", "/session/s1"));
+        (0, vitest_1.expect)(handler.getSession).toHaveBeenCalledWith("s1", undefined);
+        (0, vitest_1.expect)(await res.json()).toEqual(session);
+    });
+    (0, vitest_1.it)("GET /session/:id with invalid ?history passes undefined", async () => {
+        const handler = makeHandler();
+        const app = makeApp(handler);
+        await app.fetch(req("GET", "/session/s1?history=invalid"));
+        (0, vitest_1.expect)(handler.getSession).toHaveBeenCalledWith("s1", undefined);
+    });
+});

package/dist/src/session.test.d.ts

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

package/dist/src/session.test.js

@@ -0,0 +1,303 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const session_1 = require("./session");
+const agent_1 = require("./agent");
+const zod_1 = __importDefault(require("zod"));
+function makeModel(overrides = {}) {
+    return {
+        stream: vitest_1.vi.fn(async function* () {
+            yield { event: "text_delta", delta: "hi" };
+            yield { event: "turn_stop", stopReason: "end_turn" };
+        }),
+        call: vitest_1.vi.fn().mockResolvedValue({
+            stopReason: "end_turn",
+            messages: [{ role: "assistant", content: "hi" }],
+        }),
+        ...overrides,
+    };
+}
+function makeAgent() {
+    const agent = new agent_1.Agent("test-agent");
+    agent.tool("echo", { inputSchema: zod_1.default.object({ msg: zod_1.default.string() }) }, async ({ msg }) => msg);
+    return agent;
+}
+function makeSession(agentConfig = { name: "test-agent" }, model = makeModel(), agent = makeAgent()) {
+    return new session_1.Session("sess-1", agent, model, agentConfig);
+}
+const userMsg = { role: "user", content: "hello" };
+(0, vitest_1.describe)("Session", () => {
+    (0, vitest_1.it)("initializes with empty history and clientTools", () => {
+        const s = makeSession();
+        (0, vitest_1.expect)(s.sessionId).toBe("sess-1");
+        (0, vitest_1.expect)(s.history).toEqual([]);
+        (0, vitest_1.expect)(s.clientTools).toEqual([]);
+    });
+    (0, vitest_1.it)("toSessionResponse returns sessionId and agentConfig", () => {
+        const s = makeSession({ name: "test-agent", options: { model: "gpt-4" } });
+        (0, vitest_1.expect)(s.toSessionResponse()).toEqual({
+            sessionId: "sess-1",
+            agent: { name: "test-agent", options: { model: "gpt-4" } },
+        });
+    });
+    (0, vitest_1.it)("toSessionResponse includes tools when clientTools is set", () => {
+        const s = makeSession();
+        s.clientTools = [{ name: "t", description: "", inputSchema: {} }];
+        (0, vitest_1.expect)(s.toSessionResponse().tools).toHaveLength(1);
+    });
+    (0, vitest_1.describe)("runTurn (none mode)", () => {
+        (0, vitest_1.it)("calls model and accumulates history", async () => {
+            const s = makeSession();
+            const res = (await s.runTurn({ messages: [userMsg] }));
+            (0, vitest_1.expect)(res).toEqual({
+                stopReason: "end_turn",
+                messages: [{ role: "assistant", content: "hi" }],
+            });
+            (0, vitest_1.expect)(s.history).toHaveLength(2); // user + assistant
+        });
+        (0, vitest_1.it)("executes trusted tools inline and loops", async () => {
+            const agent = makeAgent();
+            const agentConfig = {
+                name: "test-agent",
+                tools: [{ name: "echo", trust: true }],
+            };
+            // First call returns tool_use, second returns end_turn
+            const model = makeModel({
+                call: vitest_1.vi
+                    .fn()
+                    .mockResolvedValueOnce({
+                    stopReason: "tool_use",
+                    messages: [
+                        {
+                            role: "assistant",
+                            content: [
+                                { type: "tool_use", toolCallId: "c1", name: "echo", input: { msg: "hi" } },
+                            ],
+                        },
+                    ],
+                })
+                    .mockResolvedValueOnce({
+                    stopReason: "end_turn",
+                    messages: [{ role: "assistant", content: "done" }],
+                }),
+            });
+            const s = new session_1.Session("s", agent, model, agentConfig);
+            const res = await s.runTurn({ messages: [userMsg] });
+            (0, vitest_1.expect)(res.stopReason).toBe("end_turn");
+            (0, vitest_1.expect)(model.call).toHaveBeenCalledTimes(2);
+        });
+        (0, vitest_1.it)("stops and returns tool_use when tool is untrusted", async () => {
+            const agent = makeAgent();
+            const agentConfig = {
+                name: "test-agent",
+                tools: [{ name: "echo", trust: false }],
+            };
+            const model = makeModel({
+                call: vitest_1.vi.fn().mockResolvedValue({
+                    stopReason: "tool_use",
+                    messages: [
+                        {
+                            role: "assistant",
+                            content: [{ type: "tool_use", toolCallId: "c1", name: "echo", input: { msg: "hi" } }],
+                        },
+                    ],
+                }),
+            });
+            const s = new session_1.Session("s", agent, model, agentConfig);
+            const res = (await s.runTurn({ messages: [userMsg] }));
+            (0, vitest_1.expect)(res.stopReason).toBe("tool_use");
+            (0, vitest_1.expect)(model.call).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)("runTurn (delta mode)", () => {
+        (0, vitest_1.it)("yields turn_start and turn_stop events", async () => {
+            const s = makeSession();
+            const result = s.runTurn({ messages: [userMsg], stream: "delta" });
+            const events = [];
+            for await (const e of result)
+                events.push(e);
+            (0, vitest_1.expect)(events[0].event).toBe("turn_start");
+            (0, vitest_1.expect)(events.at(-1).event).toBe("turn_stop");
+        });
+        (0, vitest_1.it)("executes trusted tools inline and loops in delta mode", async () => {
+            const agent = makeAgent();
+            const agentConfig = {
+                name: "test-agent",
+                tools: [{ name: "echo", trust: true }],
+            };
+            const model = makeModel({
+                stream: vitest_1.vi
+                    .fn()
+                    .mockImplementationOnce(async function* () {
+                    yield {
+                        event: "tool_call",
+                        toolCallId: "c1",
+                        name: "echo",
+                        input: { msg: "hi" },
+                    };
+                    yield { event: "turn_stop", stopReason: "tool_use" };
+                })
+                    .mockImplementationOnce(async function* () {
+                    yield { event: "text_delta", delta: "done" };
+                    yield { event: "turn_stop", stopReason: "end_turn" };
+                }),
+            });
+            const s = new session_1.Session("s", agent, model, agentConfig);
+            const events = [];
+            for await (const e of s.runTurn({
+                messages: [userMsg],
+                stream: "delta",
+            })) {
+                events.push(e);
+            }
+            (0, vitest_1.expect)(events.some((e) => e.event === "tool_result")).toBe(true);
+            (0, vitest_1.expect)(model.stream).toHaveBeenCalledTimes(2);
+        });
+    });
+    (0, vitest_1.describe)("runTurn (message mode)", () => {
+        (0, vitest_1.it)("yields turn_start, text, and turn_stop events", async () => {
+            const s = makeSession();
+            const result = s.runTurn({ messages: [userMsg], stream: "message" });
+            const events = [];
+            for await (const e of result)
+                events.push(e);
+            (0, vitest_1.expect)(events[0].event).toBe("turn_start");
+            (0, vitest_1.expect)(events.some((e) => e.event === "text")).toBe(true);
+            (0, vitest_1.expect)(events.at(-1).event).toBe("turn_stop");
+        });
+        (0, vitest_1.it)("yields thinking event for thinking blocks", async () => {
+            const model = makeModel({
+                call: vitest_1.vi.fn().mockResolvedValue({
+                    stopReason: "end_turn",
+                    messages: [{ role: "assistant", content: [{ type: "thinking", thinking: "hmm" }] }],
+                }),
+            });
+            const s = makeSession({ name: "test-agent" }, model);
+            const events = [];
+            for await (const e of s.runTurn({
+                messages: [userMsg],
+                stream: "message",
+            })) {
+                events.push(e);
+            }
+            (0, vitest_1.expect)(events.some((e) => e.event === "thinking")).toBe(true);
+        });
+        (0, vitest_1.it)("executes trusted tools inline and loops in message mode", async () => {
+            const agent = makeAgent();
+            const agentConfig = {
+                name: "test-agent",
+                tools: [{ name: "echo", trust: true }],
+            };
+            const model = makeModel({
+                call: vitest_1.vi
+                    .fn()
+                    .mockResolvedValueOnce({
+                    stopReason: "tool_use",
+                    messages: [
+                        {
+                            role: "assistant",
+                            content: [
+                                { type: "tool_use", toolCallId: "c1", name: "echo", input: { msg: "hi" } },
+                            ],
+                        },
+                    ],
+                })
+                    .mockResolvedValueOnce({
+                    stopReason: "end_turn",
+                    messages: [{ role: "assistant", content: "done" }],
+                }),
+            });
+            const s = new session_1.Session("s", agent, model, agentConfig);
+            const events = [];
+            for await (const e of s.runTurn({
+                messages: [userMsg],
+                stream: "message",
+            })) {
+                events.push(e);
+            }
+            (0, vitest_1.expect)(events.some((e) => e.event === "tool_result")).toBe(true);
+            (0, vitest_1.expect)(model.call).toHaveBeenCalledTimes(2);
+        });
+    });
+    (0, vitest_1.describe)("runTurn with tool_permission", () => {
+        (0, vitest_1.it)("resolves granted tool_permission into tool result", async () => {
+            const agent = makeAgent();
+            const agentConfig = { name: "test-agent" };
+            // Seed history with an assistant message containing a tool_use
+            const model = makeModel();
+            const s = new session_1.Session("s", agent, model, agentConfig);
+            s.history = [
+                { role: "user", content: "hi" },
+                {
+                    role: "assistant",
+                    content: [{ type: "tool_use", toolCallId: "c1", name: "echo", input: { msg: "hello" } }],
+                },
+            ];
+            await s.runTurn({
+                messages: [{ role: "tool_permission", toolCallId: "c1", granted: true }],
+            });
+            // model.call should have received a tool result message
+            const callArg = model.call.mock.calls[0][0];
+            const toolResult = callArg.find((m) => m.role === "tool");
+            (0, vitest_1.expect)(toolResult).toBeDefined();
+            (0, vitest_1.expect)(toolResult.content).toBe('"hello"');
+        });
+        (0, vitest_1.it)("resolves denied tool_permission with denial message", async () => {
+            const agent = makeAgent();
+            const model = makeModel();
+            const s = new session_1.Session("s", agent, model, { name: "test-agent" });
+            s.history = [
+                {
+                    role: "assistant",
+                    content: [{ type: "tool_use", toolCallId: "c2", name: "echo", input: { msg: "x" } }],
+                },
+            ];
+            await s.runTurn({
+                messages: [{ role: "tool_permission", toolCallId: "c2", granted: false, reason: "no" }],
+            });
+            const callArg = model.call.mock.calls[0][0];
+            const toolResult = callArg.find((m) => m.role === "tool");
+            (0, vitest_1.expect)(toolResult.content).toBe("Tool use denied: no");
+        });
+    });
+    (0, vitest_1.describe)("applySessionOverrides via runTurn", () => {
+        (0, vitest_1.it)("overrides clientTools when req.tools is provided", async () => {
+            const s = makeSession();
+            const newTool = { name: "x", description: "", inputSchema: {} };
+            await s.runTurn({ messages: [userMsg], tools: [newTool] });
+            (0, vitest_1.expect)(s.clientTools).toEqual([newTool]);
+        });
+        (0, vitest_1.it)("overrides agentConfig.tools when req.agent.tools is provided", async () => {
+            const s = makeSession();
+            await s.runTurn({ messages: [userMsg], agent: { tools: [{ name: "echo", trust: true }] } });
+            (0, vitest_1.expect)(s.agentConfig.tools).toEqual([{ name: "echo", trust: true }]);
+        });
+        (0, vitest_1.it)("overrides agentConfig.options when req.agent.options is provided", async () => {
+            const s = makeSession({ name: "test-agent", options: { model: "gpt-4" } });
+            await s.runTurn({ messages: [userMsg], agent: { options: { model: "gpt-5" } } });
+            (0, vitest_1.expect)(s.agentConfig.options).toEqual({ model: "gpt-5" });
+        });
+    });
+    (0, vitest_1.describe)("runNewSession", () => {
+        (0, vitest_1.it)("returns CreateSessionResponse with sessionId (none mode)", async () => {
+            const s = makeSession();
+            const res = await s.runNewSession({ agent: { name: "test-agent" }, messages: [userMsg] });
+            (0, vitest_1.expect)(res.sessionId).toBe("sess-1");
+        });
+        (0, vitest_1.it)("yields session_start event first (delta mode)", async () => {
+            const s = makeSession();
+            const result = s.runNewSession({
+                agent: { name: "test-agent" },
+                messages: [userMsg],
+                stream: "delta",
+            });
+            const events = [];
+            for await (const e of result)
+                events.push(e);
+            (0, vitest_1.expect)(events[0]).toEqual({ event: "session_start", sessionId: "sess-1" });
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentapplicationprotocol/server",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "AAP server",
   "keywords": [
     "aap",
@@ -21,17 +21,17 @@
     "directory": "packages/server"
   },
   "files": [
-    "dist",
-    "!dist/**/*.test.js",
-    "!dist/**/*.test.d.ts"
+    "dist/src",
+    "!dist/src/examples",
+    "!dist/src/**/*.test.*"
   ],
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
   "dependencies": {
     "ai": "^6.0.141",
     "hono": "^4.12.8",
     "zod": "^4.3.6",
-    "@agentapplicationprotocol/core": "0.4.1"
+    "@agentapplicationprotocol/core": "0.5.0"
   },
   "devDependencies": {
     "@ai-sdk/openai": "^3.0.48",