@agentapplicationprotocol/sdk 0.1.0 → 0.2.1

package/README.md

@@ -11,6 +11,9 @@ TypeScript SDK for the [Agent Application Protocol (AAP)](https://github.com/age
 npm install @agentapplicationprotocol/sdk
 ```
 
-## [Examples](./src/examples/)
+## Examples
 
-## [CHANGELOG](./CHANGELOG.md)
+- [Web playground](https://agentapplicationprotocol.github.io/playground/)
+- [Example agents](https://github.com/agentapplicationprotocol/agents)
+
+## [CHANGELOG](./CHANGELOG.md)

package/dist/client.d.ts

@@ -15,8 +15,17 @@ export declare class Client {
     constructor({ baseUrl, apiKey }: ClientOptions);
     private url;
     private request;
+    private streamRequest;
     /** GET /meta */
     getMeta(): Promise<MetaResponse>;
+    /** GET /sessions */
+    listSessions(params?: {
+        after?: string;
+    }): Promise<SessionListResponse>;
+    /** Fetches all session IDs across all pages. */
+    listAllSessions(): Promise<string[]>;
+    /** GET /session/:id */
+    getSession(sessionId: string): Promise<SessionResponse>;
     /** PUT /session — non-streaming */
     createSession(req: CreateSessionRequest & {
         stream?: "none";
@@ -33,14 +42,6 @@ export declare class Client {
     sendTurn(sessionId: string, req: SessionTurnRequest & {
         stream: "delta" | "message";
     }): Promise<AsyncIterable<SSEEvent>>;
-    /** GET /session/:id */
-    getSession(sessionId: string): Promise<SessionResponse>;
-    /** GET /sessions */
-    listSessions(params?: {
-        limit?: number;
-        after?: string;
-    }): Promise<SessionListResponse>;
     /** DELETE /session/:id */
     deleteSession(sessionId: string): Promise<void>;
-    private streamRequest;
 }

package/dist/client.js

@@ -15,7 +15,10 @@ exports.ClientError = ClientError;
 class Client {
     constructor({ baseUrl, apiKey }) {
         this.baseUrl = baseUrl.replace(/\/$/, "");
-        this.headers = { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` };
+        this.headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+        };
     }
     url(path) {
         return `${this.baseUrl}${path}`;
@@ -34,11 +37,48 @@ class Client {
             return undefined;
         return res.json();
     }
+    async streamRequest(method, path, body) {
+        const res = await fetch(this.url(path), {
+            method,
+            headers: { ...this.headers, Accept: "text/event-stream" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok || !res.body) {
+            const text = await res.text().catch(() => res.statusText);
+            throw new ClientError(method, path, res.status, text);
+        }
+        return parseSSE(res.body);
+    }
     /** GET /meta */
     getMeta() {
         return this.request("GET", "/meta");
     }
+    /** GET /sessions */
+    listSessions(params) {
+        let path = "/sessions";
+        if (params?.after) {
+            path += "?" + new URLSearchParams({ after: params.after }).toString();
+        }
+        return this.request("GET", path);
+    }
+    /** Fetches all session IDs across all pages. */
+    async listAllSessions() {
+        const sessions = [];
+        let after;
+        do {
+            const res = await this.listSessions({ after });
+            sessions.push(...res.sessions);
+            after = res.next;
+        } while (after);
+        return sessions;
+    }
+    /** GET /session/:id */
+    getSession(sessionId) {
+        return this.request("GET", `/session/${sessionId}`);
+    }
     createSession(req) {
+        if (req.messages.at(-1)?.role !== "user")
+            throw new Error("Last message must be a user message");
         if (req.stream === "delta" || req.stream === "message") {
             return this.streamRequest("PUT", "/session", req);
         }
@@ -50,37 +90,10 @@ class Client {
         }
         return this.request("POST", `/session/${sessionId}`, req);
     }
-    /** GET /session/:id */
-    getSession(sessionId) {
-        return this.request("GET", `/session/${sessionId}`);
-    }
-    /** GET /sessions */
-    listSessions(params) {
-        let path = "/sessions";
-        if (params) {
-            const entries = Object.entries(params).filter((e) => e[1] !== undefined);
-            if (entries.length > 0) {
-                path += "?" + new URLSearchParams(entries.map(([k, v]) => [k, String(v)])).toString();
-            }
-        }
-        return this.request("GET", path);
-    }
     /** DELETE /session/:id */
     deleteSession(sessionId) {
         return this.request("DELETE", `/session/${sessionId}`);
     }
-    async streamRequest(method, path, body) {
-        const res = await fetch(this.url(path), {
-            method,
-            headers: { ...this.headers, Accept: "text/event-stream" },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok || !res.body) {
-            const text = await res.text().catch(() => res.statusText);
-            throw new ClientError(method, path, res.status, text);
-        }
-        return parseSSE(res.body);
-    }
 }
 exports.Client = Client;
 async function* parseSSE(body) {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { Client, ClientError } from "./client";
 export type { ClientOptions } from "./client";
-export { Server, writeSSEEvents } from "./server";
+export { Server } from "./server";
 export type { ServerHandler, ServerOptions } from "./server";
-export type { Message, ToolPermissionMessage, ContentBlock, ToolSpec, ServerToolRef, AgentOption, StreamMode, StopReason, JSONSchema, AgentConfig, CreateSessionRequest, SessionTurnRequest, AgentResponse, SessionResponse, SessionListResponse, MetaResponse, AgentInfo, SSEEvent, } from "./types";
+export { sseEventsToMessages, resolvePendingToolUse } from "./utils";
+export type * from "./types";

package/dist/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSSEEvents = exports.Server = exports.ClientError = exports.Client = void 0;
+exports.resolvePendingToolUse = exports.sseEventsToMessages = exports.Server = exports.ClientError = exports.Client = void 0;
 var client_1 = require("./client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
 Object.defineProperty(exports, "ClientError", { enumerable: true, get: function () { return client_1.ClientError; } });
 var server_1 = require("./server");
 Object.defineProperty(exports, "Server", { enumerable: true, get: function () { return server_1.Server; } });
-Object.defineProperty(exports, "writeSSEEvents", { enumerable: true, get: function () { return server_1.writeSSEEvents; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "sseEventsToMessages", { enumerable: true, get: function () { return utils_1.sseEventsToMessages; } });
+Object.defineProperty(exports, "resolvePendingToolUse", { enumerable: true, get: function () { return utils_1.resolvePendingToolUse; } });

package/dist/server.d.ts

@@ -1,21 +1,26 @@
 import { Hono } from "hono";
-import type { SSEStreamingApi } from "hono/streaming";
+import type { Context } from "hono";
 import { AgentResponse, CreateSessionRequest, MetaResponse, SessionListResponse, SessionResponse, SessionTurnRequest, SSEEvent } from "./types";
 export interface ServerHandler {
     getMeta(): Promise<MetaResponse>;
-    createSession(req: CreateSessionRequest): Promise<AgentResponse | AsyncIterable<SSEEvent>> | AsyncIterable<SSEEvent>;
-    sendTurn(sessionId: string, req: SessionTurnRequest): Promise<AgentResponse | AsyncIterable<SSEEvent>> | AsyncIterable<SSEEvent>;
-    getSession(sessionId: string): Promise<SessionResponse>;
     listSessions(params: {
         after?: string;
     }): Promise<SessionListResponse>;
+    getSession(sessionId: string): Promise<SessionResponse>;
+    /** The last message in `req.messages` is guaranteed to be a user message. */
+    createSession(req: CreateSessionRequest): Promise<AgentResponse | AsyncIterable<SSEEvent>>;
+    sendTurn(sessionId: string, req: SessionTurnRequest): Promise<AgentResponse | AsyncIterable<SSEEvent>>;
     deleteSession(sessionId: string): Promise<void>;
 }
-export type { SSEStreamingApi };
-export declare function writeSSEEvents(stream: SSEStreamingApi, events: AsyncIterable<SSEEvent>): Promise<void>;
 export interface ServerOptions {
-    /** Called on every request (except GET /meta) to authenticate. Return false to reject. */
-    authenticate?: (apiKey: string) => boolean | Promise<boolean>;
+    /**
+     * Called on every request to authenticate. Return false to reject.
+     * Use `c.req.path` to allow unauthenticated access to specific routes.
+     * @example
+     * // Allow unauthenticated access to GET /meta
+     * authenticate: (apiKey, c) => c.req.path === "/meta" || apiKey === "secret"
+     */
+    authenticate?: (apiKey: string, c: Context) => boolean | Promise<boolean>;
     /** CORS origin(s) to allow. Disabled by default. */
     cors?: string | string[];
     /** Base path to mount all routes under, e.g. "/api/v1". */
@@ -24,6 +29,4 @@ export interface ServerOptions {
 export declare class Server {
     readonly app: Hono;
     constructor(handler: ServerHandler, options?: ServerOptions);
-    /** Returns the Hono fetch handler, ready to pass to any runtime (Node, Bun, Deno, etc.) */
-    fetch: (req: Request) => Response | Promise<Response>;
 }

package/dist/server.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Server = void 0;
-exports.writeSSEEvents = writeSSEEvents;
 const hono_1 = require("hono");
 const cors_1 = require("hono/cors");
 const streaming_1 = require("hono/streaming");
+// --- SSE helper ---
 async function writeSSEEvents(stream, events) {
     for await (const { event, ...data } of events) {
         await stream.writeSSE({ event, data: JSON.stringify(data) });
@@ -12,37 +12,34 @@ async function writeSSEEvents(stream, events) {
 }
 class Server {
     constructor(handler, options = {}) {
-        /** Returns the Hono fetch handler, ready to pass to any runtime (Node, Bun, Deno, etc.) */
-        this.fetch = (req) => this.app.fetch(req);
         this.app = new hono_1.Hono();
         const { authenticate } = options;
         const router = options.base ? this.app.basePath(options.base) : this.app;
         if (options.cors !== undefined) {
             router.use("*", (0, cors_1.cors)({ origin: options.cors }));
         }
-        const auth = async (apiKey) => {
-            if (!authenticate)
-                return true;
-            return authenticate(apiKey);
-        };
         const getApiKey = (authHeader) => authHeader?.startsWith("Bearer ") ? authHeader.slice(7) : "";
-        // GET /meta — auth optional
-        router.get("/meta", async (c) => {
-            const meta = await handler.getMeta();
-            return c.json(meta);
-        });
-        // Auth middleware for all other routes
+        // Auth middleware for all routes
         router.use("*", async (c, next) => {
+            if (!authenticate)
+                return next();
             const apiKey = getApiKey(c.req.header("Authorization"));
-            if (!(await auth(apiKey)))
+            if (!(await authenticate(apiKey, c)))
                 return c.json({ error: "Unauthorized" }, 401);
             return next();
         });
+        // GET /meta
+        router.get("/meta", async (c) => {
+            const meta = await handler.getMeta();
+            return c.json(meta);
+        });
         // PUT /session
         router.put("/session", async (c) => {
             const req = await c.req.json();
+            if (req.messages.at(-1)?.role !== "user")
+                return c.json({ error: "Last message must be a user message" }, 400);
             const result = await handler.createSession(req);
-            if (isAsyncIterable(result)) {
+            if (req.stream === "delta" || req.stream === "message") {
                 return (0, streaming_1.streamSSE)(c, (stream) => writeSSEEvents(stream, result));
             }
             return c.json(result, 201);
@@ -51,7 +48,7 @@ class Server {
         router.post("/session/:id", async (c) => {
             const req = await c.req.json();
             const result = await handler.sendTurn(c.req.param("id"), req);
-            if (isAsyncIterable(result)) {
+            if (req.stream === "delta" || req.stream === "message") {
                 return (0, streaming_1.streamSSE)(c, (stream) => writeSSEEvents(stream, result));
             }
             return c.json(result);
@@ -75,6 +72,3 @@ class Server {
     }
 }
 exports.Server = Server;
-function isAsyncIterable(value) {
-    return value != null && typeof value[Symbol.asyncIterator] === "function";
-}

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { JSONSchema7 } from "json-schema";
 export type JSONSchema = JSONSchema7;
+/** A single block of content within a message. */
 export type ContentBlock = {
     type: "text";
     text: string;
@@ -13,122 +14,195 @@ export type ContentBlock = {
     input: Record<string, unknown>;
 } | {
     type: "image";
-    mimeType: string;
-    data: string;
+    /** Supports `https://` URLs and `data:` URIs (base64). */
+    url: string;
 };
-export type Message = {
+/** A system-role message providing instructions to the agent. */
+export interface SystemMessage {
     role: "system";
     content: string;
-} | {
+}
+/** A user-role message. */
+export interface UserMessage {
     role: "user";
     content: string | ContentBlock[];
-} | {
+}
+/** An assistant-role message. */
+export interface AssistantMessage {
     role: "assistant";
     content: string | ContentBlock[];
-} | {
+}
+/** A tool result message returned by the application after a `tool_use` block. */
+export interface ToolMessage {
     role: "tool";
     toolCallId: string;
     content: string | ContentBlock[];
-};
-export type ToolPermissionMessage = {
+}
+/** A message that can appear in conversation history. */
+export type HistoryMessage = SystemMessage | UserMessage | AssistantMessage | ToolMessage;
+/** Grants or denies permission for the server to invoke a tool on the client's behalf. */
+export interface ToolPermissionMessage {
     role: "tool_permission";
     toolCallId: string;
+    /** Whether the client grants permission for the tool call. */
     granted: boolean;
+    /** Optional explanation, especially useful when `granted` is `false`. */
     reason?: string;
-};
+}
+/** Declares a tool (application-side in requests; server-side in `/meta`). */
 export interface ToolSpec {
     name: string;
     title?: string;
     description: string;
     inputSchema: JSONSchema;
 }
+/** References a server-side tool to enable for a session. */
 export interface ServerToolRef {
+    /** Server tool name as declared in `/meta`. */
     name: string;
-    trust: boolean;
+    /** If `true`, the server may invoke this tool without requesting client permission. Defaults to `false`. */
+    trust?: boolean;
 }
+/** A configurable option the client may set per request. */
 export type AgentOption = {
+    type: "text";
     name: string;
     title?: string;
     description?: string;
-    type: "text";
     default: string;
 } | {
+    type: "secret";
     name: string;
     title?: string;
     description?: string;
-    type: "secret";
     default: string;
 } | {
+    type: "select";
     name: string;
     title?: string;
     description?: string;
-    type: "select";
     options: string[];
     default: string;
 };
+/** Describes an agent available on the server, as returned by `GET /meta`. */
 export interface AgentInfo {
+    /** Unique identifier for the agent on this server. */
     name: string;
+    /** Human-readable display name. */
     title?: string;
+    /** Semantic version of the agent. */
     version: string;
     description?: string;
+    /** Server-side tools the agent exposes to the client for configuration. */
     tools?: ToolSpec[];
+    /** Configurable options the client may set per request. */
     options?: AgentOption[];
+    /** Declares what the agent supports. Missing fields should be treated as unsupported. */
     capabilities?: {
+        /** Declares what history the agent can return in `GET /session/:id`. */
         history?: {
+            /** Server can return compacted history. */
             compacted?: Record<string, never>;
+            /** Server can return full uncompacted history. */
             full?: Record<string, never>;
         };
+        /** Declares which stream modes the agent supports. */
         stream?: {
+            /** Agent supports `"delta"` streaming. */
             delta?: Record<string, never>;
+            /** Agent supports `"message"` streaming. */
             message?: Record<string, never>;
+            /** Agent supports non-streaming (`"none"`) responses. */
             none?: Record<string, never>;
         };
+        /** Declares what application-provided inputs the agent supports. */
         application?: {
+            /** Agent accepts application-side tools in requests. */
             tools?: Record<string, never>;
         };
+        /** Declares what image input the agent supports. */
+        image?: {
+            /** Agent accepts `https://` image URLs. */
+            http?: Record<string, never>;
+            /** Agent accepts `data:` URI (base64) images. */
+            data?: Record<string, never>;
+        };
     };
 }
+/** Response body for `GET /meta`. */
 export interface MetaResponse {
+    /** AAP protocol version. */
     version: number;
     agents: AgentInfo[];
 }
 export type StreamMode = "delta" | "message" | "none";
 export type StopReason = "end_turn" | "tool_use" | "max_tokens" | "refusal" | "error";
+/** Agent configuration supplied with a request. */
 export interface AgentConfig {
+    /** Agent name to invoke. */
     name: string;
+    /** Server-side tools to enable. If omitted, all exposed agent tools are disabled. */
     tools?: ServerToolRef[];
+    /** Key-value pairs matching the agent's declared options. */
     options?: Record<string, string>;
 }
+/** Request body for `PUT /session`. */
 export interface CreateSessionRequest {
+    /** Agent configuration. `name` is required at session creation. */
     agent: AgentConfig;
+    /** Response mode. Defaults to `"none"`. */
     stream?: StreamMode;
-    messages: Message[];
+    /** Seed history. The last message must be a `user` message. */
+    messages: HistoryMessage[];
+    /** Application-side tools with full schema. */
     tools?: ToolSpec[];
 }
+/** Request body for `POST /session/:id`. */
 export interface SessionTurnRequest {
+    /** Session-level agent overrides. Agent name cannot be changed. */
+    agent?: Omit<AgentConfig, "name">;
+    /** Response mode. Defaults to `"none"`. */
     stream?: StreamMode;
-    messages: (Message | ToolPermissionMessage)[];
+    /** A single user message, or a mixed list of tool results and tool permissions. */
+    messages: (UserMessage | ToolMessage | ToolPermissionMessage)[];
+    /** Application-side tools. Overrides tools declared at session creation. */
     tools?: ToolSpec[];
-    agent?: Omit<AgentConfig, "name">;
 }
+/** JSON response body for non-streaming (`stream: "none"`) requests. */
 export interface AgentResponse {
+    /** Present in `PUT /session` response only. */
     sessionId?: string;
     stopReason: StopReason;
-    messages: Message[];
+    messages: HistoryMessage[];
 }
+/** Response body for `GET /session/:id`. */
 export interface SessionResponse {
     sessionId: string;
+    /** Secret option values in `agent.options` are redacted (e.g. `"***"`). */
     agent: AgentConfig;
-    tools: ToolSpec[];
+    /** Application-side tools declared for this session. */
+    tools?: ToolSpec[];
     history?: {
-        compacted?: Message[];
-        full?: Message[];
+        /** Omitted if the server chooses not to expose. */
+        compacted?: HistoryMessage[];
+        /** Omitted if the server chooses not to expose. */
+        full?: HistoryMessage[];
     };
 }
+/** Response body for `GET /sessions`. */
 export interface SessionListResponse {
+    /** Array of session IDs. */
     sessions: string[];
-    nextCursor?: string;
+    /** Pagination cursor; absent when there are no more results. Pass as `after` to get the next page. */
+    next?: string;
+}
+/** A tool call emitted by the agent during a streaming turn. */
+export interface ToolCallEvent {
+    toolCallId: string;
+    name: string;
+    input: Record<string, unknown>;
 }
+/** SSE event data for `stream: "delta"` and `stream: "message"` responses. */
 export type SSEEvent = {
     event: "session_start";
     sessionId: string;
@@ -146,12 +220,9 @@ export type SSEEvent = {
 } | {
     event: "thinking";
     thinking: string;
-} | {
+} | ({
     event: "tool_call";
-    toolCallId: string;
-    name: string;
-    input: Record<string, unknown>;
-} | {
+} & ToolCallEvent) | {
     event: "tool_result";
     toolCallId: string;
     content: string | ContentBlock[];

package/dist/utils.d.ts

@@ -0,0 +1,14 @@
+import type { HistoryMessage, SSEEvent, ToolCallEvent, ToolSpec } from "./types";
+/**
+ * Converts a list of SSE events into `HistoryMessage[]`.
+ * Handles delta accumulation, tool call/result pairing, and assistant message finalization.
+ */
+export declare function sseEventsToMessages(events: SSEEvent[]): HistoryMessage[];
+/**
+ * Inspects the last assistant message in `messages` and classifies its unresolved `tool_use` blocks
+ * into client-side tools (matched against `clientTools`) and server-side tools (requiring permission).
+ */
+export declare function resolvePendingToolUse(messages: HistoryMessage[], clientTools?: ToolSpec[]): {
+    client: ToolCallEvent[];
+    server: ToolCallEvent[];
+};

package/dist/utils.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sseEventsToMessages = sseEventsToMessages;
+exports.resolvePendingToolUse = resolvePendingToolUse;
+/**
+ * Converts a list of SSE events into `HistoryMessage[]`.
+ * Handles delta accumulation, tool call/result pairing, and assistant message finalization.
+ */
+function sseEventsToMessages(events) {
+    const history = [];
+    const blocks = [];
+    let textAcc = "";
+    let thinkingAcc = "";
+    for (const event of events) {
+        // flush delta accumulators when a non-delta event arrives
+        if (event.event !== "text_delta" && event.event !== "thinking_delta") {
+            if (textAcc) {
+                blocks.push({ type: "text", text: textAcc });
+                textAcc = "";
+            }
+            if (thinkingAcc) {
+                blocks.push({ type: "thinking", thinking: thinkingAcc });
+                thinkingAcc = "";
+            }
+        }
+        switch (event.event) {
+            case "text_delta":
+                textAcc += event.delta;
+                break;
+            case "thinking_delta":
+                thinkingAcc += event.delta;
+                break;
+            case "text":
+                blocks.push({ type: "text", text: event.text });
+                break;
+            case "thinking":
+                blocks.push({ type: "thinking", thinking: event.thinking });
+                break;
+            case "tool_call":
+                // accumulate tool_use blocks into the current assistant message
+                blocks.push({
+                    type: "tool_use",
+                    toolCallId: event.toolCallId,
+                    name: event.name,
+                    input: event.input,
+                });
+                break;
+            case "tool_result":
+                // flush accumulated assistant blocks before appending the tool result
+                if (blocks.length > 0) {
+                    history.push({ role: "assistant", content: [...blocks] });
+                    blocks.length = 0;
+                }
+                history.push({ role: "tool", toolCallId: event.toolCallId, content: event.content });
+                break;
+            case "turn_stop":
+                // finalize the assistant message
+                if (blocks.length > 0)
+                    history.push({ role: "assistant", content: blocks });
+                break;
+        }
+    }
+    return history;
+}
+/**
+ * Inspects the last assistant message in `messages` and classifies its unresolved `tool_use` blocks
+ * into client-side tools (matched against `clientTools`) and server-side tools (requiring permission).
+ */
+function resolvePendingToolUse(messages, clientTools) {
+    const last = [...messages].reverse().find((m) => m.role === "assistant");
+    if (!last || !Array.isArray(last.content))
+        return { client: [], server: [] };
+    const resolved = new Set(messages.filter((m) => m.role === "tool").map((m) => m.toolCallId));
+    const clientNames = new Set(clientTools?.map((t) => t.name) ?? []);
+    const client = [];
+    const server = [];
+    for (const block of last.content) {
+        if (block.type !== "tool_use" || resolved.has(block.toolCallId))
+            continue;
+        const { toolCallId, name, input } = block;
+        (clientNames.has(name) ? client : server).push({ toolCallId, name, input });
+    }
+    return { client, server };
+}

package/package.json

@@ -1,36 +1,37 @@
 {
   "name": "@agentapplicationprotocol/sdk",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "TypeScript SDK for the Agent Application Protocol (AAP)",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "license": "Apache-2.0",
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts"
   ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "dev": "tsc --watch",
-    "example:basic:server": "tsx src/examples/01-basic/server.ts",
-    "example:basic:client": "tsx src/examples/01-basic/client.ts",
-    "example:streaming:server": "tsx src/examples/02-streaming/server.ts",
-    "example:streaming:client": "tsx src/examples/02-streaming/client.ts",
-    "example:client-tool:server": "tsx src/examples/03-client-tool/server.ts",
-    "example:client-tool:client": "tsx src/examples/03-client-tool/client.ts",
-    "example:server-tool-permission:server": "tsx src/examples/04-server-tool-permission/server.ts",
-    "example:server-tool-permission:client": "tsx src/examples/04-server-tool-permission/client.ts",
-    "example:server-tool-inline:server": "tsx src/examples/05-server-tool-inline/server.ts",
-    "example:server-tool-inline:client": "tsx src/examples/05-server-tool-inline/client.ts"
+    "test": "vitest run --exclude 'dist/**'",
+    "prepare": "husky",
+    "dev": "tsc --watch"
+  },
+  "dependencies": {
+    "eventsource-parser": "^3.0.6",
+    "hono": "^4.12.8"
   },
-  "license": "Apache-2.0",
   "devDependencies": {
-    "@hono/node-server": "^1.19.11",
     "@types/json-schema": "^7.0.15",
     "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "^4.1.2",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "oxfmt": "^0.42.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.2"
   },
-  "dependencies": {
-    "eventsource-parser": "^3.0.6",
-    "hono": "^4.12.8"
+  "lint-staged": {
+    "*.{ts,json,md}": "oxfmt"
   }
 }