@kubbi.ai/mcp 0.1.0

package/README.md

@@ -0,0 +1,172 @@
+# @kubbi.ai/mcp
+
+MCP server for [Kubbi](https://kubbi.ai) — send, claim, and inspect ephemeral encrypted payloads from any AI agent. Built on the [@kubbi.ai/sdk](https://www.npmjs.com/package/@kubbi.ai/sdk) TypeScript SDK.
+
+## What This Does
+
+This MCP server gives AI agents (Claude, Cursor, VS Code Copilot, etc.) the ability to:
+
+- **Claim** a kubbi — retrieve encrypted content using just a claim URL (zero configuration)
+- **Inspect** a kubbi — check metadata without consuming it
+- **Send** a kubbi — create an ephemeral payload and get a shareable claim URL
+- **Get/Delete** kubbis you've created
+
+The consumer tools (`kubbi_inspect`, `kubbi_claim`) need **zero auth** — any agent can receive and consume kubbis with no API key, no account, no setup. This is the killer feature for agent-to-agent handoffs.
+
+## Quick Start
+
+### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "kubbi": {
+      "command": "npx",
+      "args": ["-y", "@kubbi.ai/mcp"],
+      "env": {
+        "KUBBI_API_KEY": "kb_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to `.cursor/mcp.json` in your project or global settings:
+
+```json
+{
+  "mcpServers": {
+    "kubbi": {
+      "command": "npx",
+      "args": ["-y", "@kubbi.ai/mcp"],
+      "env": {
+        "KUBBI_API_KEY": "kb_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### VS Code
+
+Add to `.vscode/mcp.json`:
+
+```json
+{
+  "servers": {
+    "kubbi": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@kubbi.ai/mcp"],
+      "env": {
+        "KUBBI_API_KEY": "kb_your_key_here"
+      }
+    }
+  }
+}
+```
+
+> **Consumers only?** Omit `KUBBI_API_KEY` entirely. The `kubbi_inspect` and `kubbi_claim` tools will work with no configuration at all.
+
+## Environment Variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `KUBBI_API_KEY` | No* | API key for creating kubbis. Create one at [dashboard.kubbi.ai](https://dashboard.kubbi.ai). Only needed for producer tools. |
+| `KUBBI_BASE_URL` | No | API base URL (default: `https://api.kubbi.ai`) |
+
+*Producer tools (`kubbi_send`, `kubbi_send_files`, `kubbi_get`, `kubbi_delete`) require an API key. Consumer tools work without one.
+
+## Tools
+
+### kubbi_inspect (no auth)
+
+Inspect a kubbi without consuming it. Returns metadata: status, content type, retrieval count, expiry. Does not count as a retrieval.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `claimUrl` | string | Full claim URL or bare claim token |
+
+### kubbi_claim (no auth)
+
+Claim a kubbi and retrieve its decrypted content. Counts as a retrieval — if `max_retrievals` is reached, the content is permanently destroyed.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `claimUrl` | string | Full claim URL or bare claim token |
+
+### kubbi_send (requires API key)
+
+Create an ephemeral encrypted kubbi. Returns a claim URL that any consumer can use.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `content` | string or object | — | Payload to send (max 16KB) |
+| `contentType` | string | `application/json` | `text/plain` or `application/json` |
+| `ttlSeconds` | number | `3600` | Time-to-live in seconds (60–86400) |
+| `maxRetrievals` | number | unlimited | Max claims before auto-burn. `1` = burn-after-read |
+| `metadata` | object | — | Arbitrary metadata (max 1KB) |
+
+### kubbi_send_files (requires API key)
+
+Create a multi-file kubbi package — up to 5 files (5 MB total) encrypted together with a single claim URL. For binary files, base64-encode the content and set `encoding` to `"base64"`.
+
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `files` | array | — | Array of file objects (1–5, max 5 MB total) |
+| `files[].name` | string | — | Filename (e.g. `"config.json"`) |
+| `files[].content` | string | — | File content (text or base64-encoded binary) |
+| `files[].contentType` | string | `text/plain` | MIME type (e.g. `application/json`, `image/png`) |
+| `files[].role` | string | — | Semantic role: `instructions`, `data`, `context`, `config`, or `attachment` |
+| `files[].encoding` | string | — | Set to `base64` if content is base64-encoded |
+| `ttlSeconds` | number | `3600` | Time-to-live in seconds (60–86400) |
+| `maxRetrievals` | number | unlimited | Max claims before auto-burn |
+| `metadata` | object | — | Arbitrary metadata (max 1KB) |
+
+### kubbi_get (requires API key)
+
+Get detailed metadata for a kubbi you created.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `id` | string | Kubbi ID (UUID) |
+
+### kubbi_delete (requires API key)
+
+Delete a kubbi, immediately wiping the encrypted payload.
+
+| Parameter | Type | Description |
+|---|---|---|
+| `id` | string | Kubbi ID (UUID) |
+
+## Example: Agent-to-Agent Handoff
+
+**Agent A** (has API key) creates a kubbi and passes the claim URL in its response:
+
+> "I've stored the analysis results in a secure kubbi. Here's the claim URL: `https://api.kubbi.ai/r/x7k9m2...`"
+
+**Agent B** (no API key, no setup) claims it:
+
+> Tool call: `kubbi_claim({ claimUrl: "https://api.kubbi.ai/r/x7k9m2..." })`
+
+The content is retrieved and automatically destroyed (if `maxRetrievals: 1`).
+
+## Development
+
+```bash
+git clone https://github.com/kubbi/kubbi-mcp.git
+cd kubbi-mcp
+npm install
+npm run build
+
+# Test locally with MCP Inspector
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+## License
+
+MIT

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare function formatError(err: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+};

package/dist/errors.js

@@ -0,0 +1,35 @@
+import { KubbiApiError, KubbiValidationError, KubbiQuotaExceededError, KubbiRateLimitError, KubbiAuthenticationError, KubbiNotFoundError, KubbiGoneError, KubbiConflictError, KubbiNetworkError, } from "@kubbi.ai/sdk";
+export function formatError(err) {
+    let message;
+    if (err instanceof KubbiValidationError) {
+        message = `Validation error: ${err.messages?.join(", ") ?? err.message}`;
+    }
+    else if (err instanceof KubbiQuotaExceededError) {
+        message = `Quota exceeded: ${err.message}`;
+    }
+    else if (err instanceof KubbiRateLimitError) {
+        message = `Rate limited: ${err.message}. Try again shortly.`;
+    }
+    else if (err instanceof KubbiAuthenticationError) {
+        message = `Authentication failed: ${err.message}. Check your KUBBI_API_KEY.`;
+    }
+    else if (err instanceof KubbiConflictError) {
+        message = `Conflict: ${err.message}`;
+    }
+    else if (err instanceof KubbiGoneError) {
+        message = `This kubbi has been consumed or expired (410 Gone). ${err.message}`;
+    }
+    else if (err instanceof KubbiNotFoundError) {
+        message = `Not found (404). ${err.message}`;
+    }
+    else if (err instanceof KubbiNetworkError) {
+        message = `Network error contacting Kubbi API: ${err.message}`;
+    }
+    else if (err instanceof KubbiApiError) {
+        message = `Kubbi API error (${err.status}): ${err.message}`;
+    }
+    else {
+        message = `Unexpected error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    return { content: [{ type: "text", text: message }], isError: true };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { KubbiClient } from "@kubbi.ai/sdk";
+import { registerInspect } from "./tools/inspect.js";
+import { registerClaim } from "./tools/claim.js";
+import { registerSend } from "./tools/send.js";
+import { registerGet } from "./tools/get.js";
+import { registerDelete } from "./tools/delete.js";
+const apiKey = process.env.KUBBI_API_KEY;
+const baseUrl = process.env.KUBBI_BASE_URL ?? "https://api.kubbi.ai";
+const client = apiKey
+    ? new KubbiClient({ apiKey, baseUrl })
+    : null;
+const server = new McpServer({
+    name: "kubbi",
+    version: "0.1.0",
+});
+registerInspect(server, baseUrl);
+registerClaim(server, baseUrl);
+registerSend(server, client);
+registerGet(server, client);
+registerDelete(server, client);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/claim.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerClaim(server: McpServer, baseUrl: string): void;

package/dist/tools/claim.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { KubbiClient, isPackageClaim } from "@kubbi.ai/sdk";
+import { formatError } from "../errors.js";
+export function registerClaim(server, baseUrl) {
+    server.registerTool("kubbi_claim", {
+        description: "Claim a kubbi and retrieve its decrypted content. This COUNTS as a retrieval — if max_retrievals is reached, the content is permanently destroyed afterward. Works for both single-content and multi-file kubbis. Accepts a full claim URL or a bare claim token. No API key required.",
+        inputSchema: z.object({
+            claimUrl: z
+                .string()
+                .describe("Full claim URL (e.g. https://api.kubbi.ai/r/abc123) or bare claim token"),
+        }),
+    }, async ({ claimUrl }) => {
+        try {
+            const result = await KubbiClient.claim(claimUrl, { baseUrl });
+            if (isPackageClaim(result)) {
+                const lines = [
+                    `Kubbi package claimed (${result.fileCount} file${result.fileCount === 1 ? "" : "s"}).`,
+                    `Created: ${result.createdAt}`,
+                    `Expires: ${result.expiresAt}`,
+                ];
+                if (result.metadata && Object.keys(result.metadata).length > 0) {
+                    lines.push(`Metadata: ${JSON.stringify(result.metadata)}`);
+                }
+                for (const file of result.files) {
+                    lines.push("");
+                    lines.push(`--- ${file.name} (${file.contentType}, ${file.sizeBytes} bytes${file.role ? `, role: ${file.role}` : ""}) ---`);
+                    if (file.encoding === "base64") {
+                        lines.push(`[base64-encoded binary, ${file.sizeBytes} bytes]`);
+                        lines.push(file.content);
+                    }
+                    else {
+                        lines.push(file.content);
+                    }
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            const contentStr = typeof result.content === "string"
+                ? result.content
+                : JSON.stringify(result.content, null, 2);
+            const parts = [
+                `Content-Type: ${result.contentType}`,
+                `Created: ${result.createdAt}`,
+                `Expires: ${result.expiresAt}`,
+            ];
+            if (result.metadata && Object.keys(result.metadata).length > 0) {
+                parts.push(`Metadata: ${JSON.stringify(result.metadata)}`);
+            }
+            parts.push("", "--- Content ---", contentStr);
+            return {
+                content: [{ type: "text", text: parts.join("\n") }],
+            };
+        }
+        catch (err) {
+            return formatError(err);
+        }
+    });
+}

package/dist/tools/delete.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { KubbiClient } from "@kubbi.ai/sdk";
+export declare function registerDelete(server: McpServer, client: KubbiClient | null): void;

package/dist/tools/delete.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { formatError } from "../errors.js";
+const NO_KEY_MSG = "KUBBI_API_KEY is not configured. Set it in your MCP server environment to delete kubbis.";
+export function registerDelete(server, client) {
+    server.registerTool("kubbi_delete", {
+        description: "Delete (burn) a kubbi you created. Immediately wipes the encrypted payload. Any subsequent claim attempts will receive 410 Gone. Requires KUBBI_API_KEY.",
+        inputSchema: z.object({
+            id: z.string().describe("The kubbi ID (UUID) to delete"),
+        }),
+    }, async ({ id }) => {
+        if (!client) {
+            return {
+                content: [{ type: "text", text: NO_KEY_MSG }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await client.delete(id);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Kubbi ${id} deleted. Status: ${result.status}`,
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return formatError(err);
+        }
+    });
+}

package/dist/tools/get.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { KubbiClient } from "@kubbi.ai/sdk";
+export declare function registerGet(server: McpServer, client: KubbiClient | null): void;

package/dist/tools/get.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { formatError } from "../errors.js";
+const NO_KEY_MSG = "KUBBI_API_KEY is not configured. Set it in your MCP server environment to view kubbi details.";
+export function registerGet(server, client) {
+    server.registerTool("kubbi_get", {
+        description: "Get detailed metadata for a kubbi you created (by ID). Shows status, retrieval count, timestamps, and whether it has been claimed. Requires KUBBI_API_KEY.",
+        inputSchema: z.object({
+            id: z.string().describe("The kubbi ID (UUID) returned when it was created"),
+        }),
+    }, async ({ id }) => {
+        if (!client) {
+            return {
+                content: [{ type: "text", text: NO_KEY_MSG }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await client.get(id);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        catch (err) {
+            return formatError(err);
+        }
+    });
+}

package/dist/tools/inspect.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerInspect(server: McpServer, baseUrl: string): void;

package/dist/tools/inspect.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { KubbiClient, isPackageInspect } from "@kubbi.ai/sdk";
+import { formatError } from "../errors.js";
+export function registerInspect(server, baseUrl) {
+    server.registerTool("kubbi_inspect", {
+        description: "Inspect a kubbi without consuming it. Returns metadata (status, content type, retrieval count, expiry). For multi-file kubbis, also shows the file manifest. Does NOT count as a retrieval — safe to call repeatedly. Accepts a full claim URL or a bare claim token. No API key required.",
+        inputSchema: z.object({
+            claimUrl: z
+                .string()
+                .describe("Full claim URL (e.g. https://api.kubbi.ai/r/abc123) or bare claim token"),
+        }),
+    }, async ({ claimUrl }) => {
+        try {
+            const result = await KubbiClient.inspect(claimUrl, { baseUrl });
+            if (isPackageInspect(result)) {
+                const lines = [
+                    `Kubbi Package (${result.fileCount} file${result.fileCount === 1 ? "" : "s"}, ${result.totalSizeBytes} bytes total)`,
+                    `Status: ${result.status}`,
+                    `Max Retrievals: ${result.maxRetrievals ?? "unlimited"}`,
+                    `Retrieval Count: ${result.retrievalCount}`,
+                    `Remaining Reads: ${result.remainingReads ?? "unlimited"}`,
+                    `Created: ${result.createdAt}`,
+                    `Expires: ${result.expiresAt}`,
+                ];
+                if (result.metadata && Object.keys(result.metadata).length > 0) {
+                    lines.push(`Metadata: ${JSON.stringify(result.metadata)}`);
+                }
+                lines.push("", "Files:");
+                for (const file of result.files) {
+                    const rolePart = file.role ? ` (${file.role})` : "";
+                    lines.push(`  - ${file.name} [${file.contentType}, ${file.sizeBytes} bytes]${rolePart}`);
+                }
+                if (result.claim) {
+                    lines.push("", `Claim: POST ${result.claim.url}`);
+                }
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            const lines = [
+                `Status: ${result.status}`,
+                `Content-Type: ${result.contentType}`,
+                `Max Retrievals: ${result.maxRetrievals ?? "unlimited"}`,
+                `Retrieval Count: ${result.retrievalCount}`,
+                `Created: ${result.createdAt}`,
+                `Expires: ${result.expiresAt}`,
+            ];
+            if (result.metadata && Object.keys(result.metadata).length > 0) {
+                lines.push(`Metadata: ${JSON.stringify(result.metadata)}`);
+            }
+            if (result.claim) {
+                lines.push("", `Claim: POST ${result.claim.url}`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        }
+        catch (err) {
+            return formatError(err);
+        }
+    });
+}

package/dist/tools/send.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { KubbiClient } from "@kubbi.ai/sdk";
+export declare function registerSend(server: McpServer, client: KubbiClient | null): void;

package/dist/tools/send.js

@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { formatError } from "../errors.js";
+const NO_KEY_MSG = "KUBBI_API_KEY is not configured. Set it in your MCP server environment to create kubbis. Consumer tools (kubbi_inspect, kubbi_claim) work without a key.";
+export function registerSend(server, client) {
+    server.registerTool("kubbi_send", {
+        description: "Create a kubbi — an ephemeral, encrypted payload with a unique claim URL. Share the claim URL with any consumer (agent, service, human). The consumer can retrieve the content with no API key. Requires KUBBI_API_KEY.",
+        inputSchema: z.object({
+            content: z
+                .union([z.string(), z.record(z.unknown())])
+                .describe("Payload to send — a string or JSON object (max 16KB)"),
+            contentType: z
+                .enum(["text/plain", "application/json"])
+                .default("application/json")
+                .describe("MIME type of the content"),
+            ttlSeconds: z
+                .number()
+                .min(60)
+                .max(86400)
+                .default(3600)
+                .describe("Time-to-live in seconds (60–86400). Default: 3600 (1 hour)"),
+            maxRetrievals: z
+                .number()
+                .min(1)
+                .optional()
+                .describe("Max number of claims before auto-burn. Set to 1 for burn-after-read. Omit for unlimited."),
+            metadata: z
+                .record(z.unknown())
+                .optional()
+                .describe("Arbitrary metadata attached to the kubbi (max 1KB)"),
+        }),
+    }, async ({ content, contentType, ttlSeconds, maxRetrievals, metadata }) => {
+        if (!client) {
+            return {
+                content: [{ type: "text", text: NO_KEY_MSG }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await client.send({
+                content,
+                contentType,
+                ttlSeconds,
+                maxRetrievals,
+                metadata,
+            });
+            const lines = [
+                "Kubbi created successfully.",
+                "",
+                `Claim URL: ${result.claimUrl}`,
+                `ID: ${result.id}`,
+                `Status: ${result.status}`,
+                `Content-Type: ${result.contentType}`,
+                `Max Retrievals: ${result.maxRetrievals ?? "unlimited"}`,
+                `Expires: ${result.expiresAt}`,
+            ];
+            if (result.metadata && Object.keys(result.metadata).length > 0) {
+                lines.push(`Metadata: ${JSON.stringify(result.metadata)}`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        }
+        catch (err) {
+            return formatError(err);
+        }
+    });
+    server.registerTool("kubbi_send_files", {
+        description: "Create a multi-file kubbi package — up to 5 files (5 MB total) encrypted together with a single claim URL. For text files, pass content as a string. For binary files, base64-encode the content and set encoding to 'base64'. Requires KUBBI_API_KEY.",
+        inputSchema: z.object({
+            files: z
+                .array(z.object({
+                name: z.string().describe("Filename (e.g. 'config.json', 'readme.md')"),
+                content: z.string().describe("File content as a string (text) or base64-encoded string (binary)"),
+                contentType: z
+                    .string()
+                    .default("text/plain")
+                    .describe("MIME type (e.g. 'text/plain', 'application/json', 'image/png')"),
+                role: z
+                    .enum(["instructions", "data", "context", "config", "attachment"])
+                    .optional()
+                    .describe("Semantic role of the file"),
+                encoding: z
+                    .enum(["base64"])
+                    .optional()
+                    .describe("Set to 'base64' if content is base64-encoded binary"),
+            }))
+                .min(1)
+                .max(5)
+                .describe("Array of files (1–5, max 5 MB total)"),
+            ttlSeconds: z
+                .number()
+                .min(60)
+                .max(86400)
+                .default(3600)
+                .describe("Time-to-live in seconds (60–86400). Default: 3600 (1 hour)"),
+            maxRetrievals: z
+                .number()
+                .min(1)
+                .optional()
+                .describe("Max number of claims before auto-burn. Omit for unlimited."),
+            metadata: z
+                .record(z.unknown())
+                .optional()
+                .describe("Arbitrary metadata attached to the kubbi (max 1KB)"),
+        }),
+    }, async ({ files, ttlSeconds, maxRetrievals, metadata }) => {
+        if (!client) {
+            return {
+                content: [{ type: "text", text: NO_KEY_MSG }],
+                isError: true,
+            };
+        }
+        try {
+            const result = await client.sendFiles({
+                files,
+                ttlSeconds,
+                maxRetrievals,
+                metadata,
+            });
+            const lines = [
+                "Multi-file kubbi created successfully.",
+                "",
+                `Claim URL: ${result.claimUrl}`,
+                `ID: ${result.id}`,
+                `Status: ${result.status}`,
+                `Files: ${result.fileCount}`,
+                `Total Size: ${result.totalSizeBytes} bytes`,
+                `Max Retrievals: ${result.maxRetrievals ?? "unlimited"}`,
+                `Expires: ${result.expiresAt}`,
+            ];
+            if (result.metadata && Object.keys(result.metadata).length > 0) {
+                lines.push(`Metadata: ${JSON.stringify(result.metadata)}`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        }
+        catch (err) {
+            return formatError(err);
+        }
+    });
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@kubbi.ai/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for Kubbi — send, claim, and inspect ephemeral encrypted payloads from any AI agent",
+  "type": "module",
+  "bin": {
+    "kubbi-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "kubbi",
+    "mcp",
+    "model-context-protocol",
+    "ephemeral",
+    "encrypted",
+    "payload",
+    "handoff",
+    "agent",
+    "ai",
+    "tool"
+  ],
+  "author": "Kubbi",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@kubbi.ai/sdk": "^0.1.0",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.6.0"
+  }
+}