sunpeak 0.15.4 → 0.16.2

package/dist/mcp/production-server.d.ts

@@ -0,0 +1,156 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { AuthInfo, CallToolResult, ToolHandlerExtra } from './types.js';
+/**
+ * A tool loaded from a compiled tool module (`dist/tools/*.js`).
+ */
+export interface ProductionTool {
+    /** Tool name (derived from filename, e.g. 'show-albums') */
+    name: string;
+    /** Tool config from the `tool` export */
+    tool: {
+        resource: string;
+        title?: string;
+        description?: string;
+        annotations?: Record<string, unknown>;
+        _meta?: Record<string, unknown>;
+    };
+    /** Zod shape from the `schema` export (passed to SDK as inputSchema) */
+    schema?: Record<string, unknown>;
+    /** Handler from the `default` export */
+    handler: (args: Record<string, unknown>, extra: ToolHandlerExtra) => CallToolResult | Promise<CallToolResult> | string | Promise<string>;
+}
+/**
+ * A resource loaded from the build output (`dist/{name}/{name}.html` + `.json`).
+ */
+export interface ProductionResource {
+    /** Resource name (from .json metadata) */
+    name: string;
+    /** Resource URI (from .json metadata, includes cache-bust timestamp) */
+    uri: string;
+    /** Pre-built HTML content (self-contained, JS+CSS inlined) */
+    html: string;
+    /** Resource _meta (CSP, permissions, domain, etc.) */
+    _meta?: Record<string, unknown>;
+    /** Resource description */
+    description?: string;
+}
+/**
+ * Auth function signature for `src/server.ts` (Node.js).
+ * Called on every MCP request. Return AuthInfo to authenticate, null to reject (401).
+ */
+export type AuthFunction = (req: IncomingMessage) => Promise<AuthInfo | null> | AuthInfo | null;
+/**
+ * Auth function signature for Web Standard handlers (Cloudflare Workers, Deno, Bun).
+ */
+export type WebAuthFunction = (req: Request) => Promise<AuthInfo | null> | AuthInfo | null;
+/**
+ * Configuration for creating a production MCP server and Node.js handler.
+ */
+export interface ProductionServerConfig {
+    /** Server name reported to hosts */
+    name?: string;
+    /** Server version reported to hosts */
+    version?: string;
+    /** Tool registrations with real handlers */
+    tools: ProductionTool[];
+    /** Resource registrations with pre-built HTML */
+    resources: ProductionResource[];
+    /** Auth function from server entry (populates extra.authInfo via req.auth) */
+    auth?: AuthFunction;
+}
+/**
+ * Configuration for creating a Web Standard MCP handler (serverless/edge).
+ */
+export interface WebHandlerConfig {
+    /** Server name reported to hosts */
+    name?: string;
+    /** Server version reported to hosts */
+    version?: string;
+    /** Tool registrations with real handlers */
+    tools: ProductionTool[];
+    /** Resource registrations with pre-built HTML */
+    resources: ProductionResource[];
+    /** Auth function for Web Standard Request objects */
+    auth?: WebAuthFunction;
+}
+/**
+ * Create an MCP server with production tool handlers and pre-built resources.
+ *
+ * Tools are registered with real Zod schemas (input validation) and handlers.
+ * Resources serve pre-built HTML with their _meta preserved.
+ */
+export declare function createProductionMcpServer(config: ProductionServerConfig): McpServer;
+/**
+ * Create a request handler that manages MCP sessions over Streamable HTTP.
+ *
+ * The returned handler responds to:
+ * - `POST /mcp` — Initialize a session or send messages
+ * - `GET /mcp` — Open an SSE stream for server-initiated notifications
+ * - `DELETE /mcp` — Terminate a session
+ * - `OPTIONS /mcp` — CORS preflight
+ *
+ * For any other request, the handler does nothing (doesn't write to `res`),
+ * so callers can chain it with their own routing.
+ *
+ * @example
+ * ```ts
+ * import express from 'express';
+ * import { createMcpHandler } from 'sunpeak/mcp';
+ *
+ * const app = express();
+ * app.get('/health', (req, res) => res.json({ ok: true }));
+ *
+ * const mcpHandler = createMcpHandler({ tools, resources, auth });
+ * app.use((req, res, next) => {
+ *   mcpHandler(req, res).then(() => {
+ *     if (!res.headersSent) next();
+ *   });
+ * });
+ *
+ * app.listen(3000);
+ * ```
+ */
+export declare function createMcpHandler(config: ProductionServerConfig): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+/**
+ * Create a Web Standard request handler for MCP over Streamable HTTP.
+ *
+ * Returns a `(req: Request) => Promise<Response>` handler that works on any
+ * Web Standard runtime: Cloudflare Workers, Deno, Bun, Vercel Edge, etc.
+ *
+ * Unlike `createMcpHandler`, this handler does NOT do path matching — it handles
+ * every request it receives. Mount it behind your own router.
+ *
+ * @example
+ * ```ts
+ * // Cloudflare Worker
+ * import { createHandler } from 'sunpeak/mcp';
+ *
+ * const handler = createHandler({ tools, resources, auth });
+ * export default { fetch: handler };
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Hono
+ * import { Hono } from 'hono';
+ * import { createHandler } from 'sunpeak/mcp';
+ *
+ * const app = new Hono();
+ * const handler = createHandler({ tools, resources });
+ * app.all('/mcp', (c) => handler(c.req.raw));
+ * export default app;
+ * ```
+ */
+export declare function createHandler(config: WebHandlerConfig): (req: Request) => Promise<Response>;
+/**
+ * Start a production HTTP server with Streamable HTTP transport.
+ *
+ * This is a convenience wrapper around `createMcpHandler` that adds
+ * a root HTML page, favicon, and graceful shutdown. For custom HTTP
+ * servers (Express, Fastify, etc.), use `createMcpHandler` directly.
+ *
+ * @param config - Production server configuration (tools, resources, auth)
+ * @param port - HTTP port to listen on
+ */
+export declare function startProductionHttpServer(config: ProductionServerConfig, port: number): void;

package/dist/mcp/types.d.ts

@@ -1,4 +1,27 @@
-import { Resource, Tool } from '@modelcontextprotocol/sdk/types.js';
+import { Resource, Tool, ServerRequest, ServerNotification } from '@modelcontextprotocol/sdk/types.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { ToolConfig } from '@modelcontextprotocol/ext-apps/server';
+export type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+/**
+ * Extra context passed to tool handlers as the second argument.
+ *
+ * This is a pre-applied alias for the MCP SDK's `RequestHandlerExtra` —
+ * no custom fields, just ergonomic generics so users don't need to parameterize it.
+ *
+ * Key fields: `authInfo`, `sessionId`, `signal`, `_meta`.
+ */
+export type ToolHandlerExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
+/**
+ * Configuration for a Sunpeak tool file's `tool` export.
+ *
+ * Extends the ext-apps `ToolConfig` with a `resource` field that links
+ * the tool to a resource by its unique name string.
+ */
+export interface AppToolConfig extends ToolConfig {
+    /** The resource name (must match a directory in `src/resources/`, e.g. `'albums'`). */
+    resource: string;
+}
 /**
  * Simulation configuration for MCP server.
  * Must include distPath for the built HTML file.

package/dist/platform/chatgpt/index.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const React = require("react");
-const useApp = require("../../use-app-BnoSPiUT.cjs");
+const useApp = require("../../use-app-BpAJqzdE.cjs");
 function getOpenAIRuntime() {
   if (typeof window !== "undefined" && "openai" in window) {
     return window.openai;

package/dist/platform/chatgpt/index.js

@@ -1,5 +1,5 @@
 import { useCallback } from "react";
-import { u as useApp } from "../../use-app-D_TeaMFG.js";
+import { u as useApp } from "../../use-app-WOUdh1PR.js";
 function getOpenAIRuntime() {
   if (typeof window !== "undefined" && "openai" in window) {
     return window.openai;

package/dist/{protocol-DFbsCx7E.js → protocol-BD5jDQEx.js}

@@ -7863,6 +7863,7 @@ function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
 }
 const LATEST_PROTOCOL_VERSION = "2025-11-25";
+const DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 const SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
 const RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 const JSONRPC_VERSION = "2.0";
@@ -8188,6 +8189,7 @@ const InitializeRequestSchema = RequestSchema.extend({
   method: literal("initialize"),
   params: InitializeRequestParamsSchema
 });
+const isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
 const ServerCapabilitiesSchema = object({
   /**
    * Experimental, non-standard capabilities that the server supports.
@@ -11557,6 +11559,7 @@ function mergeCapabilities(base, additional) {
   return result;
 }
 export {
+  isJSONRPCRequest as $,
   ListRootsResultSchema as A,
   safeParse$1 as B,
   ContentBlockSchema as C,
@@ -11583,7 +11586,11 @@ export {
   getLiteralValue as X,
   getSchemaDescription as Y,
   isSchemaOptional as Z,
+  isInitializeRequest as _,
   CallToolResultSchema as a,
+  DEFAULT_NEGOTIATED_PROTOCOL_VERSION as a0,
+  isJSONRPCResultResponse as a1,
+  isJSONRPCErrorResponse as a2,
   PingRequestSchema as b,
   CallToolRequestSchema as c,
   LoggingMessageNotificationSchema as d,
@@ -11610,4 +11617,4 @@ export {
   ElicitResultSchema as y,
   ErrorCode as z
 };
-//# sourceMappingURL=protocol-DFbsCx7E.js.map
+//# sourceMappingURL=protocol-BD5jDQEx.js.map