@silkweave/edge 0.1.0 → 3.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Silkweave
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,155 @@
+# @silkweave/edge
+
+Web-Standard edge/serverless adapter for [Silkweave](https://github.com/silkweave/silkweave) - deploy your actions as a **stateless** MCP server on any `(Request) => Response` runtime: **Cloudflare Workers, Vercel, Bun, Deno, Hono**, and Next.js.
+
+It uses only Web Standard APIs (`Request`/`Response`/`ReadableStream`/Web Crypto) and the SDK's `WebStandardStreamableHTTPServerTransport` - no Express, no port binding - so the same handler drops onto any edge or serverless platform.
+
+## Install
+
+```bash
+pnpm add @silkweave/core @silkweave/edge
+```
+
+## Usage
+
+### Vanilla serverless function (Vercel / Bun / Deno)
+
+```typescript
+// api/mcp.ts
+import { silkweave } from '@silkweave/core'
+import { edge } from '@silkweave/edge'
+import { MyAction } from '../actions/my-action.js'
+
+const { adapter, handler } = edge()
+
+await silkweave({ name: 'my-tools', description: 'My MCP Server', version: '1.0.0' })
+  .adapter(adapter)
+  .action(MyAction)
+  .start()
+
+export default { fetch: handler }
+```
+
+### Next.js App Router
+
+```typescript
+// app/api/mcp/route.ts
+import { silkweave } from '@silkweave/core'
+import { edge } from '@silkweave/edge'
+import { MyAction } from '../../../actions/my-action.js'
+
+const { adapter, GET, POST, DELETE } = edge()
+
+await silkweave({ name: 'my-tools', description: 'My MCP Server', version: '1.0.0' })
+  .adapter(adapter)
+  .action(MyAction)
+  .start()
+
+export { GET, POST, DELETE }
+```
+
+> For Next.js, [`@silkweave/nextjs`](https://www.npmjs.com/package/@silkweave/nextjs) wraps this adapter with catch-all path normalization and end-to-end tRPC types - prefer it over wiring `edge()` by hand.
+
+### Cloudflare Workers
+
+See the full [`examples/cloudflare`](https://github.com/silkweave/silkweave/tree/master/examples/cloudflare) example - a Worker with stateless MCP + Google Workspace OAuth 2.1 and OAuth state in Cloudflare KV, with a from-scratch setup guide.
+
+## How It Works
+
+- Uses `WebStandardStreamableHTTPServerTransport` from the MCP SDK in **stateless mode** (`sessionIdGenerator: undefined`)
+- Each request creates a fresh `McpServer` + transport, registers tools, handles the request, and returns a Web Standard `Response`
+- Only `POST` carries JSON-RPC; `GET` (standing SSE stream) and `DELETE` (session teardown) return `405`, since stateless mode has no session to attach a stream to or tear down (a `GET` stream would otherwise hang the request on serverless runtimes like Cloudflare Workers)
+- Actions are registered as MCP tools using `PascalCase` names (same as the stdio and http adapters)
+- Tool results use `smartToolResult()` by default. Large payloads (> 4096 chars) are automatically split into a text summary + embedded resource to reduce LLM context bloat. Actions can override this with a custom `toolResult` hook.
+- Logging goes to `process.stderr` (serverless log drain) and MCP client notifications
+
+## Streaming Actions
+
+Streaming actions (see [`@silkweave/core`](https://www.npmjs.com/package/@silkweave/core)) work identically to [`@silkweave/mcp`](https://www.npmjs.com/package/@silkweave/mcp)'s `http()` adapter - chunks are delivered as `notifications/progress` over the Streamable HTTP transport when the client sends `_meta.progressToken`, with the JSON-stringified chunk in the `message` field. The tool call resolves with the buffered chunk array as the `CallToolResult`.
+
+The same AI-host caveat applies as for stdio/http MCP: chunks reach the wire as standard MCP progress notifications, but most LLM hosts today consume them for UI rendering rather than as incremental data fed into the model's context. See the [`@silkweave/mcp` README](https://www.npmjs.com/package/@silkweave/mcp#what-this-means-for-ai-hosts) for the full discussion.
+
+## Auth
+
+`edge()` serves the full OAuth 2.1 surface when you pass an `auth` config - protected-resource metadata (RFC 9728), `/authorize`, `/token`, `/register`, and the provider callback - alongside the MCP transport, all from the one handler. Pass a bearer-validating `AuthConfig` from [`@silkweave/auth`](https://www.npmjs.com/package/@silkweave/auth), or a full provider (e.g. `google()`) from `@silkweave/auth/oauth`:
+
+```typescript
+import { google } from '@silkweave/auth/oauth'
+
+const { adapter, handler } = edge({ auth: google({ /* clientId, clientSecret, resourceUrl, store, ... */ }) })
+```
+
+## Options
+
+```typescript
+const { adapter, handler } = edge({
+  enableJsonResponse: true  // Return JSON instead of SSE streams
+})
+```
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enableJsonResponse` | `boolean` | `false` | Return JSON responses instead of SSE streams |
+| `auth` | `AuthConfig` | - | Bearer-token validation + OAuth routes (see [Auth](#auth)) |
+| `path` | `string` | `/mcp` | The MCP transport path |
+
+## Compound Return Pattern
+
+Unlike other Silkweave adapters that are simple `AdapterFactory` functions, `edge()` returns a compound object:
+
+```typescript
+interface EdgeAdapter {
+  adapter: AdapterGenerator                          // Pass to silkweave().adapter()
+  handler: (request: Request) => Promise<Response>   // The request handler
+  GET: (request: Request) => Promise<Response>       // Alias for handler
+  POST: (request: Request) => Promise<Response>      // Alias for handler
+  DELETE: (request: Request) => Promise<Response>    // Alias for handler
+}
+```
+
+This is because edge/serverless platforms export request handlers rather than starting long-lived servers. The `adapter` property integrates with the Silkweave builder, while `handler`/`GET`/`POST`/`DELETE` are exported from your route file.
+
+## Deployment
+
+### Vercel configuration
+
+```json
+{
+  "framework": null,
+  "functions": {
+    "api/mcp.ts": {
+      "memory": 1024,
+      "maxDuration": 60
+    }
+  },
+  "rewrites": [
+    { "source": "/mcp", "destination": "/api/mcp" }
+  ]
+}
+```
+
+### CORS
+
+CORS is not handled by the adapter (beyond OAuth/preflight). Configure it in your host framework - Next.js middleware, `vercel.json` headers, or Worker response headers:
+
+```json
+{
+  "headers": [
+    {
+      "source": "/api/mcp",
+      "headers": [
+        { "key": "Access-Control-Allow-Origin", "value": "*" },
+        { "key": "Access-Control-Allow-Methods", "value": "POST, OPTIONS" },
+        { "key": "Access-Control-Allow-Headers", "value": "Content-Type, Authorization" }
+      ]
+    }
+  ]
+}
+```
+
+## See Also
+
+- [Silkweave README](https://github.com/silkweave/silkweave) - Full documentation
+- [`@silkweave/core`](https://www.npmjs.com/package/@silkweave/core) - Core library
+- [`@silkweave/mcp`](https://www.npmjs.com/package/@silkweave/mcp) - MCP stdio and HTTP adapters
+- [`examples/cloudflare`](https://github.com/silkweave/silkweave/tree/master/examples/cloudflare) - Cloudflare Worker + Google OAuth + KV example

package/build/index.d.mts

@@ -0,0 +1,20 @@
+import { AuthConfig } from "@silkweave/auth";
+import { AdapterGenerator } from "@silkweave/core";
+
+//#region src/adapter/edge.d.ts
+interface EdgeAdapterOptions {
+  enableJsonResponse?: boolean;
+  auth?: AuthConfig;
+  path?: string;
+}
+interface EdgeAdapter {
+  adapter: AdapterGenerator;
+  handler: (request: Request) => Promise<Response>;
+  GET: (request: Request) => Promise<Response>;
+  POST: (request: Request) => Promise<Response>;
+  DELETE: (request: Request) => Promise<Response>;
+}
+declare function edge(options?: EdgeAdapterOptions): EdgeAdapter;
+//#endregion
+export { EdgeAdapter, EdgeAdapterOptions, edge };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/adapter/edge.ts"],"mappings":";;;;UAMiB,kBAAA;EACf,kBAAA;EACA,IAAA,GAAO,UAAA;EACP,IAAA;AAAA;AAAA,UAGe,WAAA;EACf,OAAA,EAAS,gBAAA;EACT,OAAA,GAAU,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;EACvC,GAAA,GAAM,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;EACnC,IAAA,GAAO,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;EACpC,MAAA,GAAS,OAAA,EAAS,OAAA,KAAY,OAAA,CAAQ,QAAA;AAAA;AAAA,iBA0DxB,IAAA,CAAK,OAAA,GAAS,kBAAA,GAA0B,WAAA"}

package/build/index.mjs

@@ -0,0 +1,150 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { generateProtectedResourceMetadata, validateToken } from "@silkweave/auth";
+import { registerTools } from "@silkweave/mcp/tools";
+//#region src/adapter/edge.ts
+const CORS_HEADERS = {
+	"Access-Control-Allow-Origin": "*",
+	"Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+	"Access-Control-Allow-Headers": "*",
+	"Access-Control-Max-Age": "86400"
+};
+async function parseOAuthRequest(url, request) {
+	let body;
+	if (request.method === "POST") {
+		const contentType = request.headers.get("content-type") ?? "";
+		const text = await request.text();
+		if (contentType.includes("json")) body = JSON.parse(text);
+		else body = Object.fromEntries(new URLSearchParams(text));
+	}
+	return {
+		method: request.method,
+		url,
+		headers: Object.fromEntries(request.headers.entries()),
+		body
+	};
+}
+function oauthResponseToResponse(oauthRes) {
+	const responseBody = oauthRes.body ? typeof oauthRes.body === "string" ? oauthRes.body : JSON.stringify(oauthRes.body) : null;
+	return new Response(responseBody, {
+		status: oauthRes.status,
+		headers: oauthRes.headers
+	});
+}
+async function routeOAuth(url, request, provider, callbackPath) {
+	const oauthReq = await parseOAuthRequest(url, request);
+	let oauthRes;
+	if (url.pathname === "/.well-known/oauth-authorization-server") oauthRes = provider.metadata();
+	else if (url.pathname === "/authorize") oauthRes = await provider.authorize(oauthReq);
+	else if (url.pathname === callbackPath) oauthRes = await provider.callback(oauthReq);
+	else if (url.pathname === "/token") oauthRes = await provider.token(oauthReq);
+	else oauthRes = await provider.register(oauthReq);
+	return oauthResponseToResponse(oauthRes);
+}
+function edge(options = {}) {
+	const mcpPath = options.path ?? "/mcp";
+	const callbackPath = options.auth?.callbackPath ?? "/auth/callback";
+	let _actions = [];
+	let _options = null;
+	let _context = null;
+	let _readyResolve;
+	const _ready = new Promise((resolve) => {
+		_readyResolve = resolve;
+	});
+	const validPaths = new Set([mcpPath]);
+	if (options.auth?.authorizationServers?.length && options.auth.resourceUrl) validPaths.add("/.well-known/oauth-protected-resource");
+	if (options.auth?.provider) {
+		validPaths.add("/.well-known/oauth-authorization-server");
+		validPaths.add("/authorize");
+		validPaths.add(callbackPath);
+		validPaths.add("/token");
+		validPaths.add("/register");
+	}
+	const oauthPaths = options.auth?.provider ? {
+		"/.well-known/oauth-authorization-server": ["GET"],
+		"/authorize": ["GET"],
+		[callbackPath]: ["GET"],
+		"/token": ["POST"],
+		"/register": ["POST"]
+	} : null;
+	const handleRequest = async (request) => {
+		const url = new URL(request.url);
+		if (!validPaths.has(url.pathname)) return new Response("Not Found", { status: 404 });
+		if (request.method === "OPTIONS") return new Response(null, {
+			status: 200,
+			headers: CORS_HEADERS
+		});
+		if (url.pathname === "/.well-known/oauth-protected-resource") {
+			const metadata = generateProtectedResourceMetadata(options.auth.resourceUrl, options.auth.authorizationServers, options.auth.requiredScopes);
+			return new Response(JSON.stringify(metadata), { headers: {
+				...CORS_HEADERS,
+				"Content-Type": "application/json",
+				"Cache-Control": "max-age=3600"
+			} });
+		}
+		if (oauthPaths) {
+			const methods = oauthPaths[url.pathname];
+			if (methods) {
+				if (!methods.includes(request.method)) return new Response("Method not allowed", { status: 405 });
+				return routeOAuth(url, request, options.auth.provider, callbackPath);
+			}
+		}
+		if (request.method !== "POST") return new Response("Method Not Allowed", {
+			status: 405,
+			headers: {
+				...CORS_HEADERS,
+				Allow: "POST"
+			}
+		});
+		await _ready;
+		let requestContext = _context;
+		if (options.auth) {
+			const result = await validateToken(request.headers.get("authorization"), options.auth, _context.fork({ request }));
+			if (result.error) return new Response(JSON.stringify(result.error.body), {
+				status: result.error.statusCode,
+				headers: result.error.headers
+			});
+			if (result.auth) requestContext = _context.fork({ auth: result.auth });
+		}
+		const transport = new WebStandardStreamableHTTPServerTransport({
+			sessionIdGenerator: void 0,
+			enableJsonResponse: options.enableJsonResponse
+		});
+		const server = new McpServer({
+			name: _options.name,
+			description: _options.description,
+			version: _options.version
+		}, { capabilities: {
+			tools: {},
+			logging: {}
+		} });
+		registerTools(server, _actions, requestContext);
+		await server.connect(transport);
+		return transport.handleRequest(request);
+	};
+	const adapter = (silkweaveOptions, baseContext) => {
+		_options = silkweaveOptions;
+		_context = baseContext.fork({ adapter: "edge" });
+		return {
+			context: _context,
+			start: async (actions) => {
+				_actions = actions;
+				_readyResolve();
+			},
+			stop: async () => {
+				_actions = [];
+			}
+		};
+	};
+	return {
+		adapter,
+		handler: handleRequest,
+		GET: handleRequest,
+		POST: handleRequest,
+		DELETE: handleRequest
+	};
+}
+//#endregion
+export { edge };
+
+//# sourceMappingURL=index.mjs.map

package/build/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/adapter/edge.ts"],"sourcesContent":["import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'\nimport { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js'\nimport { AuthConfig, generateProtectedResourceMetadata, OAuthRequest, OAuthResponse, validateToken } from '@silkweave/auth'\nimport { Action, AdapterGenerator, SilkweaveContext, SilkweaveOptions } from '@silkweave/core'\nimport { registerTools } from '@silkweave/mcp/tools'\n\nexport interface EdgeAdapterOptions {\n  enableJsonResponse?: boolean\n  auth?: AuthConfig\n  path?: string\n}\n\nexport interface EdgeAdapter {\n  adapter: AdapterGenerator\n  handler: (request: Request) => Promise<Response>\n  GET: (request: Request) => Promise<Response>\n  POST: (request: Request) => Promise<Response>\n  DELETE: (request: Request) => Promise<Response>\n}\n\nconst CORS_HEADERS: Record<string, string> = {\n  'Access-Control-Allow-Origin': '*',\n  'Access-Control-Allow-Methods': 'GET, POST, DELETE, OPTIONS',\n  'Access-Control-Allow-Headers': '*',\n  'Access-Control-Max-Age': '86400'\n}\n\nasync function parseOAuthRequest(url: URL, request: Request): Promise<OAuthRequest> {\n  let body: Record<string, string> | undefined\n  if (request.method === 'POST') {\n    const contentType = request.headers.get('content-type') ?? ''\n    const text = await request.text()\n    if (contentType.includes('json')) {\n      body = JSON.parse(text)\n    } else {\n      body = Object.fromEntries(new URLSearchParams(text))\n    }\n  }\n  return {\n    method: request.method,\n    url,\n    headers: Object.fromEntries(request.headers.entries()),\n    body\n  }\n}\n\nfunction oauthResponseToResponse(oauthRes: OAuthResponse): Response {\n  const responseBody = oauthRes.body\n    ? (typeof oauthRes.body === 'string' ? oauthRes.body : JSON.stringify(oauthRes.body))\n    : null\n  return new Response(responseBody, { status: oauthRes.status, headers: oauthRes.headers })\n}\n\nasync function routeOAuth(\n  url: URL,\n  request: Request,\n  provider: NonNullable<AuthConfig['provider']>,\n  callbackPath: string\n): Promise<Response> {\n  const oauthReq = await parseOAuthRequest(url, request)\n  let oauthRes\n  if (url.pathname === '/.well-known/oauth-authorization-server') {\n    oauthRes = provider.metadata()\n  } else if (url.pathname === '/authorize') {\n    oauthRes = await provider.authorize(oauthReq)\n  } else if (url.pathname === callbackPath) {\n    oauthRes = await provider.callback(oauthReq)\n  } else if (url.pathname === '/token') {\n    oauthRes = await provider.token(oauthReq)\n  } else {\n    oauthRes = await provider.register(oauthReq)\n  }\n  return oauthResponseToResponse(oauthRes)\n}\n\nexport function edge(options: EdgeAdapterOptions = {}): EdgeAdapter {\n  const mcpPath = options.path ?? '/mcp'\n  const callbackPath = options.auth?.callbackPath ?? '/auth/callback'\n\n  let _actions: Action[] = []\n  let _options: SilkweaveOptions | null = null\n  let _context: SilkweaveContext | null = null\n  let _readyResolve: () => void\n  const _ready = new Promise<void>((resolve) => {\n    _readyResolve = resolve\n  })\n\n  // Pre-compute valid paths for fast rejection of bogus requests\n  const validPaths = new Set<string>([mcpPath])\n  if (options.auth?.authorizationServers?.length && options.auth.resourceUrl) {\n    validPaths.add('/.well-known/oauth-protected-resource')\n  }\n  if (options.auth?.provider) {\n    validPaths.add('/.well-known/oauth-authorization-server')\n    validPaths.add('/authorize')\n    validPaths.add(callbackPath)\n    validPaths.add('/token')\n    validPaths.add('/register')\n  }\n\n  // OAuth path → allowed methods (built once, not per-request)\n  const oauthPaths: Record<string, string[]> | null = options.auth?.provider\n    ? {\n      '/.well-known/oauth-authorization-server': ['GET'],\n      '/authorize': ['GET'],\n      [callbackPath]: ['GET'],\n      '/token': ['POST'],\n      '/register': ['POST']\n    }\n    : null\n\n  const handleRequest = async (request: Request): Promise<Response> => {\n    const url = new URL(request.url)\n\n    // Fast rejection - no async work, no allocations for unknown paths\n    if (!validPaths.has(url.pathname)) {\n      return new Response('Not Found', { status: 404 })\n    }\n\n    // CORS preflight\n    if (request.method === 'OPTIONS') {\n      return new Response(null, { status: 200, headers: CORS_HEADERS })\n    }\n\n    // Protected resource metadata (RFC 9728)\n    if (url.pathname === '/.well-known/oauth-protected-resource') {\n      const metadata = generateProtectedResourceMetadata(options.auth!.resourceUrl!, options.auth!.authorizationServers!, options.auth!.requiredScopes)\n      return new Response(JSON.stringify(metadata), {\n        headers: { ...CORS_HEADERS, 'Content-Type': 'application/json', 'Cache-Control': 'max-age=3600' }\n      })\n    }\n\n    // OAuth provider routes\n    if (oauthPaths) {\n      const methods = oauthPaths[url.pathname]\n      if (methods) {\n        if (!methods.includes(request.method)) {\n          return new Response('Method not allowed', { status: 405 })\n        }\n        return routeOAuth(url, request, options.auth!.provider!, callbackPath)\n      }\n    }\n\n    // MCP transport (stateless): only POST carries JSON-RPC. A standing-stream\n    // GET or a session-teardown DELETE has no session to act on - and the SDK's\n    // GET handler would open an SSE stream that never closes, hanging the request\n    // on serverless runtimes (e.g. Cloudflare Workers). Answer them with 405, which\n    // the Streamable HTTP spec explicitly permits for servers without a GET stream.\n    if (request.method !== 'POST') {\n      return new Response('Method Not Allowed', {\n        status: 405,\n        headers: { ...CORS_HEADERS, Allow: 'POST' }\n      })\n    }\n\n    // wait for silkweave().start() to complete\n    await _ready\n\n    let requestContext = _context!\n    if (options.auth) {\n      const result = await validateToken(request.headers.get('authorization'), options.auth, _context!.fork({ request }))\n      if (result.error) {\n        return new Response(JSON.stringify(result.error.body), {\n          status: result.error.statusCode,\n          headers: result.error.headers\n        })\n      }\n      if (result.auth) {\n        requestContext = _context!.fork({ auth: result.auth })\n      }\n    }\n\n    const transport = new WebStandardStreamableHTTPServerTransport({\n      sessionIdGenerator: undefined,\n      enableJsonResponse: options.enableJsonResponse\n    })\n\n    const server = new McpServer({\n      name: _options!.name,\n      description: _options!.description,\n      version: _options!.version\n    }, {\n      capabilities: { tools: {}, logging: {} }\n    })\n\n    registerTools(server, _actions, requestContext)\n\n    await server.connect(transport)\n    return transport.handleRequest(request)\n  }\n\n  const adapter: AdapterGenerator = (silkweaveOptions: SilkweaveOptions, baseContext: SilkweaveContext) => {\n    _options = silkweaveOptions\n    _context = baseContext.fork({ adapter: 'edge' })\n    return {\n      context: _context,\n      start: async (actions) => {\n        _actions = actions\n        _readyResolve()\n      },\n      stop: async () => {\n        _actions = []\n      }\n    }\n  }\n\n  return {\n    adapter,\n    handler: handleRequest,\n    GET: handleRequest,\n    POST: handleRequest,\n    DELETE: handleRequest\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,7 +1,54 @@
 {
   "name": "@silkweave/edge",
-  "version": "0.1.0",
-  "publishConfig": {
-    "access": "public"
+  "version": "3.1.0",
+  "description": "Silkweave Web-Standard edge/serverless adapter (Cloudflare Workers, Vercel, Bun, Deno, Hono)",
+  "license": "MIT",
+  "homepage": "https://www.silkweave.dev",
+  "bugs": {
+    "url": "https://github.com/silkweave/silkweave/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/silkweave/silkweave.git",
+    "directory": "packages/edge"
+  },
+  "type": "module",
+  "main": "./build/index.mjs",
+  "types": "./build/index.d.mts",
+  "files": [
+    "build"
+  ],
+  "exports": {
+    ".": {
+      "@silkweave/source": "./src/index.ts",
+      "types": "./build/index.d.mts",
+      "default": "./build/index.mjs"
+    }
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^3.25.0",
+    "@silkweave/auth": "3.1.0",
+    "@silkweave/core": "3.1.0",
+    "@silkweave/mcp": "3.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/node": "^22.0.0",
+    "eslint": "^10.4.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.21.8",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.56.1"
+  },
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "tsdown",
+    "watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint",
+    "check": "pnpm lint && pnpm typecheck"
   }
 }