@agentapplicationprotocol/server 0.4.2 → 0.6.0

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

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

package/dist/src/agent.test.js

@@ -0,0 +1,61 @@
+"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 agent_1 = require("./agent");
+const zod_1 = __importDefault(require("zod"));
+(0, vitest_1.describe)("Agent", () => {
+    (0, vitest_1.it)("initializes with name and defaults", () => {
+        const agent = new agent_1.Agent("my-agent");
+        (0, vitest_1.expect)(agent.info.name).toBe("my-agent");
+        (0, vitest_1.expect)(agent.info.version).toBe("1.0.0");
+        (0, vitest_1.expect)(agent.info.tools).toEqual([]);
+        (0, vitest_1.expect)(agent.tools.size).toBe(0);
+    });
+    (0, vitest_1.it)("accepts title, description, version options", () => {
+        const agent = new agent_1.Agent("a", { title: "T", description: "D", version: "2.0.0" });
+        (0, vitest_1.expect)(agent.info.title).toBe("T");
+        (0, vitest_1.expect)(agent.info.description).toBe("D");
+        (0, vitest_1.expect)(agent.info.version).toBe("2.0.0");
+    });
+    (0, vitest_1.it)("option() adds an option and returns this", () => {
+        const agent = new agent_1.Agent("a");
+        const result = agent.option({ type: "text", name: "model", default: "gpt-4" });
+        (0, vitest_1.expect)(result).toBe(agent);
+        (0, vitest_1.expect)(agent.info.options).toHaveLength(1);
+        (0, vitest_1.expect)(agent.info.options[0].name).toBe("model");
+    });
+    (0, vitest_1.it)("image() sets image capability and returns this", () => {
+        const agent = new agent_1.Agent("a");
+        const result = agent.image({ http: {} });
+        (0, vitest_1.expect)(result).toBe(agent);
+        (0, vitest_1.expect)(agent.info.capabilities?.image).toEqual({ http: {} });
+    });
+    (0, vitest_1.it)("history() sets history capability and returns this", () => {
+        const agent = new agent_1.Agent("a");
+        const result = agent.history({});
+        (0, vitest_1.expect)(result).toBe(agent);
+        (0, vitest_1.expect)(agent.info.capabilities?.history).toEqual({});
+    });
+    (0, vitest_1.it)("tool() registers tool spec and executor", async () => {
+        const agent = new agent_1.Agent("a");
+        agent.tool("add", {
+            description: "adds two numbers",
+            inputSchema: zod_1.default.object({ a: zod_1.default.number(), b: zod_1.default.number() }),
+            outputSchema: zod_1.default.number(),
+        }, async ({ a, b }) => a + b);
+        (0, vitest_1.expect)(agent.info.tools).toHaveLength(1);
+        (0, vitest_1.expect)(agent.info.tools[0].name).toBe("add");
+        (0, vitest_1.expect)(agent.tools.has("add")).toBe(true);
+        const result = await agent.tools.get("add")(JSON.stringify({ a: 2, b: 3 }));
+        (0, vitest_1.expect)(JSON.parse(result)).toBe(5);
+    });
+    (0, vitest_1.it)("tool() validates output with outputSchema", async () => {
+        const agent = new agent_1.Agent("a");
+        agent.tool("greet", { inputSchema: zod_1.default.object({ name: zod_1.default.string() }), outputSchema: zod_1.default.string() }, async ({ name }) => `hello ${name}`);
+        const result = await agent.tools.get("greet")(JSON.stringify({ name: "world" }));
+        (0, vitest_1.expect)(JSON.parse(result)).toBe("hello world");
+    });
+});

package/dist/src/examples/basic/index.d.ts

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

package/dist/src/examples/basic/index.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_server_1 = require("@hono/node-server");
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("zod");
+const hono_1 = require("hono");
+const cors_1 = require("hono/cors");
+const server_js_1 = require("../../server.js");
+const agent_js_1 = require("../../agent.js");
+const model_js_1 = require("../../model.js");
+const openai_1 = require("@ai-sdk/openai");
+const session_js_1 = require("../../session.js");
+/** In-memory session store. */
+const sessions = new Map();
+/** Agent definition with options, capabilities, and tools. */
+const agent = new agent_js_1.Agent("basic-agent", {
+    version: "0.1.0",
+    description: "An AAP-compatible agent powered by Vercel AI SDK.",
+})
+    .image({ http: {}, data: {} })
+    .history({ compacted: {}, full: {} })
+    .option({
+    name: "baseURL",
+    title: "LLM Base URL",
+    description: "OpenAI-compatible base URL",
+    type: "text",
+    default: "",
+})
+    .option({
+    name: "apiKey",
+    title: "LLM API Key",
+    description: "OpenAI API key",
+    type: "secret",
+    default: "",
+})
+    .option({
+    name: "model",
+    title: "Model",
+    description: "Model ID to use",
+    type: "text",
+    default: "gpt-4o",
+})
+    .tool("web_fetch", {
+    description: "Fetch the text content of a URL",
+    inputSchema: zod_1.z.object({ url: zod_1.z.string().describe("URL to fetch") }),
+}, async ({ url }) => {
+    const res = await fetch(url);
+    const text = await res.text();
+    return text
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 8000);
+});
+const handler = {
+    getMeta() {
+        return { agents: [agent.info] };
+    },
+    createSession(req) {
+        const sessionId = `sess_${(0, node_crypto_1.randomUUID)()}`;
+        // Build the model from client-supplied options
+        const openai = (0, openai_1.createOpenAI)({
+            baseURL: req.agent.options?.baseURL || undefined,
+            apiKey: req.agent.options?.apiKey || undefined,
+        });
+        const model = new model_js_1.AiModelProvider(openai.chat(req.agent.options?.model ?? "gpt-4o"));
+        const session = new session_js_1.Session(sessionId, agent, model, req.agent, req.tools);
+        sessions.set(sessionId, session);
+        return session.runNewSession(req);
+    },
+    sendTurn(sessionId, req) {
+        const session = sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        return session.runTurn(req);
+    },
+    async getSession(sessionId) {
+        const session = sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        return session.toSessionResponse();
+    },
+    async getSessionHistory(sessionId, type) {
+        const session = sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        // history is never compacted, so compacted and full are the same
+        return session.history;
+    },
+    async listSessions() {
+        return { sessions: [...sessions.values()].map((s) => s.toSessionResponse()) };
+    },
+    async deleteSession(sessionId) {
+        sessions.delete(sessionId);
+    },
+};
+const port = Number(process.env.PORT ?? 3010);
+const app = new hono_1.Hono();
+app.use("*", (0, cors_1.cors)({ origin: "*" }));
+app.route("/", (0, server_js_1.aap)(handler));
+(0, node_server_1.serve)({ fetch: app.fetch, port });
+console.log(`basic-agent running on http://localhost:${port}`);

package/dist/src/examples/compact-history/index.d.ts

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

package/dist/src/examples/compact-history/index.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_server_1 = require("@hono/node-server");
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("zod");
+const hono_1 = require("hono");
+const cors_1 = require("hono/cors");
+const server_js_1 = require("../../server.js");
+const agent_js_1 = require("../../agent.js");
+const model_js_1 = require("../../model.js");
+const openai_1 = require("@ai-sdk/openai");
+const session_js_1 = require("./session.js");
+/** Agent definition with options, capabilities, and tools. */
+const agent = new agent_js_1.Agent("compact-history-agent", {
+    version: "0.1.0",
+    description: "An AAP-compatible agent with sliding-window history compaction, powered by Vercel AI SDK.",
+})
+    .image({ http: {}, data: {} })
+    .history({ compacted: {}, full: {} })
+    .option({
+    name: "baseURL",
+    title: "LLM Base URL",
+    description: "OpenAI-compatible base URL",
+    type: "text",
+    default: "",
+})
+    .option({
+    name: "apiKey",
+    title: "LLM API Key",
+    description: "OpenAI API key",
+    type: "secret",
+    default: "",
+})
+    .option({
+    name: "model",
+    title: "Model",
+    description: "Model ID to use",
+    type: "text",
+    default: "gpt-4o",
+})
+    .tool("web_fetch", {
+    description: "Fetch the text content of a URL",
+    inputSchema: zod_1.z.object({ url: zod_1.z.string().describe("URL to fetch") }),
+}, async ({ url }) => {
+    const res = await fetch(url);
+    const text = await res.text();
+    return text
+        .replace(/<[^>]+>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 8000);
+});
+const handler = {
+    getMeta() {
+        return { agents: [agent.info] };
+    },
+    createSession(req) {
+        const sessionId = `sess_${(0, node_crypto_1.randomUUID)()}`;
+        // Build the model from client-supplied options
+        const openai = (0, openai_1.createOpenAI)({
+            baseURL: req.agent.options?.baseURL || undefined,
+            apiKey: req.agent.options?.apiKey || undefined,
+        });
+        const model = new model_js_1.AiModelProvider(openai.chat(req.agent.options?.model ?? "gpt-4o"));
+        const session = new session_js_1.TruncatedHistorySession(sessionId, agent, model, req.agent, req.tools);
+        session_js_1.sessions.set(sessionId, session);
+        return session.runNewSession(req);
+    },
+    sendTurn(sessionId, req) {
+        const session = session_js_1.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        return session.runTurn(req);
+    },
+    async getSession(sessionId) {
+        const session = session_js_1.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        return session.toSessionResponse();
+    },
+    async getSessionHistory(sessionId, type) {
+        const session = session_js_1.sessions.get(sessionId);
+        if (!session)
+            throw new Error(`Session not found: ${sessionId}`);
+        return type === "compacted" ? session.history : session.fullHistory;
+    },
+    async listSessions() {
+        return { sessions: [...session_js_1.sessions.values()].map((s) => s.toSessionResponse()) };
+    },
+    async deleteSession(sessionId) {
+        session_js_1.sessions.delete(sessionId);
+    },
+};
+const port = Number(process.env.PORT ?? 3010);
+const app = new hono_1.Hono();
+app.use("*", (0, cors_1.cors)({ origin: "*" }));
+app.route("/", (0, server_js_1.aap)(handler));
+(0, node_server_1.serve)({ fetch: app.fetch, port });
+console.log(`compact-history-agent running on http://localhost:${port}`);

package/dist/src/examples/compact-history/session.d.ts

@@ -0,0 +1,18 @@
+import type { AgentResponse, DeltaSSEEvent, HistoryMessage } from "@agentapplicationprotocol/core";
+import { Session } from "../../session.js";
+/** In-memory session store. */
+export declare const sessions: Map<string, TruncatedHistorySession>;
+/**
+ * Session subclass with sliding-window history compaction.
+ * `this.history` holds the compacted window sent to the model.
+ * `fullHistory` retains the complete uncompacted history.
+ */
+export declare class TruncatedHistorySession extends Session {
+    fullHistory: HistoryMessage[];
+    /** Appends new history entries to `fullHistory` and trims `this.history` to the compacted window. */
+    private syncAndCompact;
+    /** Streams the model response, then compacts history. */
+    protected stream(messages: HistoryMessage[]): AsyncIterable<DeltaSSEEvent>;
+    /** Calls the model, then compacts history. */
+    protected call(messages: HistoryMessage[]): Promise<AgentResponse>;
+}

package/dist/src/examples/compact-history/session.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TruncatedHistorySession = exports.sessions = void 0;
+const session_js_1 = require("../../session.js");
+/** In-memory session store. */
+exports.sessions = new Map();
+const COMPACTED_HISTORY_SIZE = 10;
+/** Trims history to the last `COMPACTED_HISTORY_SIZE` messages, ensuring the window never starts on a `tool` message. */
+function compact(history) {
+    if (history.length <= COMPACTED_HISTORY_SIZE)
+        return history;
+    let start = history.length - COMPACTED_HISTORY_SIZE;
+    // skip leading tool messages to avoid orphaned tool results
+    while (start < history.length && history[start].role === "tool")
+        start++;
+    return history.slice(start);
+}
+/**
+ * Session subclass with sliding-window history compaction.
+ * `this.history` holds the compacted window sent to the model.
+ * `fullHistory` retains the complete uncompacted history.
+ */
+class TruncatedHistorySession extends session_js_1.Session {
+    constructor() {
+        super(...arguments);
+        this.fullHistory = [];
+    }
+    /** Appends new history entries to `fullHistory` and trims `this.history` to the compacted window. */
+    syncAndCompact(before) {
+        this.fullHistory.push(...this.history.slice(before));
+        this.history = compact(this.history);
+    }
+    /** Streams the model response, then compacts history. */
+    async *stream(messages) {
+        const before = this.history.length;
+        for await (const e of super.stream(messages))
+            yield e;
+        this.syncAndCompact(before);
+    }
+    /** Calls the model, then compacts history. */
+    async call(messages) {
+        const before = this.history.length;
+        const res = await super.call(messages);
+        this.syncAndCompact(before);
+        return res;
+    }
+}
+exports.TruncatedHistorySession = TruncatedHistorySession;

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

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

package/dist/src/model.test.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const model_1 = require("./model");
+// --- ModelProvider base class ---
+class ConcreteModel extends model_1.ModelProvider {
+    async *stream(_history) {
+        yield { event: "text_delta", delta: "hello" };
+        yield { event: "turn_stop", stopReason: "end_turn" };
+    }
+}
+(0, vitest_1.describe)("ModelProvider", () => {
+    (0, vitest_1.it)("call() falls back to stream() and returns AgentResponse", async () => {
+        const model = new ConcreteModel();
+        const res = await model.call([{ role: "user", content: "hi" }], []);
+        (0, vitest_1.expect)(res.stopReason).toBe("end_turn");
+        (0, vitest_1.expect)(res.messages).toHaveLength(1);
+        (0, vitest_1.expect)(res.messages[0]).toMatchObject({ role: "assistant" });
+    });
+});
+function makeLM() {
+    return {
+        specificationVersion: "v2",
+        provider: "test",
+        modelId: "test-model",
+        defaultObjectGenerationMode: undefined,
+        doStream: vitest_1.vi.fn(),
+        doGenerate: vitest_1.vi.fn(),
+    };
+}
+function mockStream(lm, chunks) {
+    lm.doStream.mockResolvedValue({
+        stream: new ReadableStream({
+            start(controller) {
+                for (const chunk of chunks)
+                    controller.enqueue(chunk);
+                controller.close();
+            },
+        }),
+        rawValue: {},
+        warnings: [],
+    });
+}
+function mockGenerate(lm, finishReason, content) {
+    lm.doGenerate.mockResolvedValue({
+        finishReason,
+        usage: { inputTokens: 1, outputTokens: 1 },
+        content,
+        rawValue: {},
+        warnings: [],
+        response: { id: "r1", timestamp: new Date(), modelId: "test-model", headers: {} },
+    });
+}
+(0, vitest_1.describe)("AiModelProvider", () => {
+    (0, vitest_1.it)("stores the language model", () => {
+        const lm = makeLM();
+        (0, vitest_1.expect)(new model_1.AiModelProvider(lm).model).toBe(lm);
+    });
+    (0, vitest_1.it)("stream() yields text_delta and turn_stop", async () => {
+        const lm = makeLM();
+        mockStream(lm, [
+            { type: "text-delta", id: "t1", delta: "hello", providerMetadata: undefined },
+            {
+                type: "finish",
+                finishReason: "stop",
+                usage: { inputTokens: 1, outputTokens: 1 },
+                providerMetadata: undefined,
+            },
+        ]);
+        const events = [];
+        for await (const e of new model_1.AiModelProvider(lm).stream([{ role: "user", content: "hi" }], [])) {
+            events.push(e);
+        }
+        (0, vitest_1.expect)(events.some((e) => e.event === "text_delta")).toBe(true);
+        (0, vitest_1.expect)(events.some((e) => e.event === "turn_stop")).toBe(true);
+    });
+    (0, vitest_1.it)("stream() yields thinking_delta and tool_call", async () => {
+        const lm = makeLM();
+        mockStream(lm, [
+            { type: "reasoning-delta", id: "r1", delta: "hmm", providerMetadata: undefined },
+            {
+                type: "tool-call",
+                toolCallId: "c1",
+                toolName: "fn",
+                input: { x: 1 },
+                providerMetadata: undefined,
+            },
+            {
+                type: "finish",
+                finishReason: "tool-calls",
+                usage: { inputTokens: 1, outputTokens: 1 },
+                providerMetadata: undefined,
+            },
+        ]);
+        const events = [];
+        for await (const e of new model_1.AiModelProvider(lm).stream([{ role: "user", content: "hi" }], [])) {
+            events.push(e);
+        }
+        (0, vitest_1.expect)(events.some((e) => e.event === "thinking_delta")).toBe(true);
+        (0, vitest_1.expect)(events.some((e) => e.event === "tool_call")).toBe(true);
+        (0, vitest_1.expect)(events.find((e) => e.event === "turn_stop")).toMatchObject({ stopReason: "tool_use" });
+    });
+    (0, vitest_1.it)("call() returns AgentResponse with text content", async () => {
+        const lm = makeLM();
+        mockGenerate(lm, "stop", [{ type: "text", text: "done" }]);
+        const res = await new model_1.AiModelProvider(lm).call([{ role: "user", content: "hi" }], []);
+        (0, vitest_1.expect)(res.stopReason).toBe("end_turn");
+        (0, vitest_1.expect)(res.messages[0].role).toBe("assistant");
+    });
+    (0, vitest_1.it)("call() maps reasoning and tool-call blocks in response", async () => {
+        const lm = makeLM();
+        mockGenerate(lm, "stop", [
+            { type: "reasoning", text: "thinking..." },
+            { type: "tool-call", toolCallId: "c1", toolName: "fn", input: { x: 1 } },
+        ]);
+        const res = await new model_1.AiModelProvider(lm).call([{ role: "user", content: "hi" }], []);
+        const blocks = res.messages.find((m) => m.role === "assistant").content;
+        (0, vitest_1.expect)(blocks.some((b) => b.type === "thinking")).toBe(true);
+        (0, vitest_1.expect)(blocks.some((b) => b.type === "tool_use")).toBe(true);
+    });
+    (0, vitest_1.it)("call() passes system, image (data URI), assistant with thinking/tool_use, and tool messages", async () => {
+        const lm = makeLM();
+        mockGenerate(lm, "tool-calls", [
+            { type: "tool-call", toolCallId: "c1", toolName: "fn", input: { x: 1 } },
+        ]);
+        const history = [
+            { role: "system", content: "be helpful" },
+            { role: "user", content: [{ type: "image", url: "data:image/png;base64,abc" }] },
+            {
+                role: "assistant",
+                content: [
+                    { type: "thinking", thinking: "hmm" },
+                    { type: "tool_use", toolCallId: "c1", name: "fn", input: { x: 1 } },
+                ],
+            },
+            { role: "tool", toolCallId: "c1", content: "result" },
+        ];
+        const res = await new model_1.AiModelProvider(lm).call(history, []);
+        (0, vitest_1.expect)(res.stopReason).toBe("tool_use");
+    });
+    (0, vitest_1.it)("call() maps finishReason variants correctly", async () => {
+        const cases = [
+            ["length", "max_tokens"],
+            ["content-filter", "refusal"],
+            ["error", "error"],
+        ];
+        for (const [finishReason, expected] of cases) {
+            const lm = makeLM();
+            mockGenerate(lm, finishReason, []);
+            const res = await new model_1.AiModelProvider(lm).call([{ role: "user", content: "hi" }], []);
+            (0, vitest_1.expect)(res.stopReason).toBe(expected);
+        }
+    });
+});

package/dist/src/server.d.ts

@@ -1,11 +1,12 @@
 import { Hono } from "hono";
-import { AgentResponse, CreateSessionRequest, CreateSessionResponse, MetaResponse, SessionListResponse, SessionResponse, SessionTurnRequest, SSEEvent } from "@agentapplicationprotocol/core";
+import { AgentResponse, CreateSessionRequest, CreateSessionResponse, HistoryMessage, MetaResponse, SessionListResponse, SessionResponse, SessionTurnRequest, SSEEvent } from "@agentapplicationprotocol/core";
 export interface Handler {
-    getMeta(): MetaResponse;
+    getMeta(): Omit<MetaResponse, "version">;
     listSessions(params: {
         after?: string;
     }): Promise<SessionListResponse>;
-    getSession(sessionId: string, history?: "compacted" | "full"): Promise<SessionResponse>;
+    getSession(sessionId: string): Promise<SessionResponse>;
+    getSessionHistory(sessionId: string, type: "compacted" | "full"): Promise<HistoryMessage[]>;
     /** The last message in `req.messages` is guaranteed to be a user message. */
     createSession(req: CreateSessionRequest): Promise<CreateSessionResponse> | AsyncIterable<SSEEvent>;
     sendTurn(sessionId: string, req: SessionTurnRequest): Promise<AgentResponse> | AsyncIterable<SSEEvent>;

package/dist/src/server.js

@@ -41,7 +41,7 @@ function redactSecretOptions(session, agents) {
  */
 function aap(handler) {
     const router = new hono_1.Hono();
-    router.get("/meta", (c) => c.json(handler.getMeta()));
+    router.get("/meta", (c) => c.json({ version: 2, ...handler.getMeta() }));
     router.put("/session", async (c) => {
         const req = await c.req.json();
         if (req.messages.at(-1)?.role !== "user")
@@ -61,20 +61,16 @@ function aap(handler) {
         return c.json(result);
     });
     router.get("/session/:id", async (c) => {
-        const historyParam = c.req.query("history");
-        const history = historyParam === "compacted" || historyParam === "full" ? historyParam : undefined;
-        const session = await handler.getSession(c.req.param("id"), history);
-        // strip history fields not matching the requested mode
-        if (session.history) {
-            if (history === "compacted")
-                delete session.history.full;
-            else if (history === "full")
-                delete session.history.compacted;
-            else
-                session.history = undefined;
-        }
-        const meta = handler.getMeta();
-        return c.json(redactSecretOptions(session, meta.agents));
+        const session = await handler.getSession(c.req.param("id"));
+        const { agents } = handler.getMeta();
+        return c.json(redactSecretOptions(session, agents));
+    });
+    router.get("/session/:id/history", async (c) => {
+        const typeParam = c.req.query("type");
+        if (typeParam !== "compacted" && typeParam !== "full")
+            return c.json({ error: 'type must be "compacted" or "full"' }, 400);
+        const messages = await handler.getSessionHistory(c.req.param("id"), typeParam);
+        return c.json({ history: { [typeParam]: messages } });
     });
     router.get("/sessions", async (c) => {
         const after = c.req.query("after");

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

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

package/dist/src/server.test.js

@@ -0,0 +1,208 @@
+"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: 2, agents: [] };
+const session = { sessionId: "s1", agent: { name: "a" } };
+const agentResponse = { stopReason: "end_turn", messages: [] };
+const createSessionResponse = { ...agentResponse, sessionId: "s1" };
+const sessionList = { sessions: [session] };
+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({ agents: [] }),
+        listSessions: vitest_1.vi.fn().mockResolvedValue(sessionList),
+        getSession: vitest_1.vi.fn().mockResolvedValue(session),
+        getSessionHistory: vitest_1.vi.fn().mockResolvedValue([]),
+        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 app = makeApp(makeHandler({
+            getSession: vitest_1.vi.fn().mockResolvedValue(secretSession),
+            getMeta: vitest_1.vi.fn().mockReturnValue({
+                agents: [
+                    {
+                        name: "a",
+                        version: "1.0.0",
+                        options: [
+                            { type: "secret", name: "key", default: "" },
+                            { type: "text", name: "model", default: "" },
+                        ],
+                    },
+                ],
+            }),
+        }));
+        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({ 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({
+                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?type=compacted calls getSessionHistory", async () => {
+        const messages = [{ role: "user", content: "hi" }];
+        const handler = makeHandler({ getSessionHistory: vitest_1.vi.fn().mockResolvedValue(messages) });
+        const app = makeApp(handler);
+        const res = await app.fetch(req("GET", "/session/s1/history?type=compacted"));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(handler.getSessionHistory).toHaveBeenCalledWith("s1", "compacted");
+        (0, vitest_1.expect)(await res.json()).toEqual({ history: { compacted: messages } });
+    });
+    (0, vitest_1.it)("GET /session/:id/history?type=full calls getSessionHistory", async () => {
+        const messages = [{ role: "user", content: "hi" }];
+        const handler = makeHandler({ getSessionHistory: vitest_1.vi.fn().mockResolvedValue(messages) });
+        const app = makeApp(handler);
+        const res = await app.fetch(req("GET", "/session/s1/history?type=full"));
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(handler.getSessionHistory).toHaveBeenCalledWith("s1", "full");
+        (0, vitest_1.expect)(await res.json()).toEqual({ history: { full: messages } });
+    });
+    (0, vitest_1.it)("GET /session/:id/history without valid ?type returns 400", async () => {
+        const app = makeApp(makeHandler());
+        const res = await app.fetch(req("GET", "/session/s1/history"));
+        (0, vitest_1.expect)(res.status).toBe(400);
+    });
+});

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.2",
+  "version": "0.6.0",
   "description": "AAP server",
   "keywords": [
     "aap",
@@ -22,6 +22,7 @@
   },
   "files": [
     "dist/src",
+    "!dist/src/examples",
     "!dist/src/**/*.test.*"
   ],
   "main": "dist/src/index.js",
@@ -30,7 +31,7 @@
     "ai": "^6.0.141",
     "hono": "^4.12.8",
     "zod": "^4.3.6",
-    "@agentapplicationprotocol/core": "0.4.2"
+    "@agentapplicationprotocol/core": "0.6.0"
   },
   "devDependencies": {
     "@ai-sdk/openai": "^3.0.48",