@creature-ai/sdk 0.1.8 → 0.1.10

package/dist/server/index.d.ts

@@ -47,13 +47,9 @@ interface AdapterOptions {
     realtimeAdapter?: RealtimeAdapter;
 }
 /**
- * Options for vercelMcp adapter.
+ * Options for Vercel serverless handler.
  */
 interface VercelMcpOptions extends AdapterOptions {
-    /** Base path for MCP routes (default: '/api'). */
-    basePath?: string;
-    /** Maximum duration for serverless function (default: 60). */
-    maxDuration?: number;
 }
 /**
  * Options for awsLambda adapter.
@@ -508,13 +504,16 @@ declare class App {
      */
     getResourceDefinitions(): Map<string, ResourceDefinition>;
     /**
-     * Create a Vercel MCP adapter configuration.
-     * For use with Vercel's `mcp-handler` package.
+     * Create a Vercel serverless function handler.
+     * Works with plain Vercel Serverless Functions - no Next.js or mcp-handler needed.
      *
-     * Note: This returns a configuration callback. The implementation
-     * is inline to avoid circular dependencies.
+     * Usage in api/mcp.ts:
+     * ```ts
+     * import { app } from "../src/app";
+     * export default app.toVercelFunctionHandler();
+     * ```
      */
-    toVercelMcp(options?: VercelMcpOptions): (server: any, _context: any) => void;
+    toVercelFunctionHandler(options?: VercelMcpOptions): (reqOrRequest: any, res?: any) => Promise<any>;
     /**
      * Create an AWS Lambda handler.
      *
@@ -555,10 +554,19 @@ declare class App {
      */
     private formatServerlessResult;
     /**
-     * Create a Vercel MCP configuration callback.
-     * Returns a function compatible with Vercel's mcp-handler createMcpHandler.
+     * Create a Vercel serverless function handler.
+     * Handles MCP JSON-RPC protocol directly - no mcp-handler or Next.js needed.
+     */
+    private createVercelHandler;
+    /**
+     * Handle an MCP JSON-RPC request.
+     * Shared logic for all serverless handlers.
+     */
+    private handleMcpRequest;
+    /**
+     * Convert Zod schema to JSON Schema for tool definitions.
      */
-    private createServerlessConfig;
+    private zodToJsonSchema;
     /**
      * Create an AWS Lambda handler function.
      */

package/dist/server/index.js

@@ -12180,7 +12180,7 @@ var toRequestError = (e) => {
   return new RequestError(e.message, { cause: e });
 };
 var GlobalRequest = global.Request;
-var Request = class extends GlobalRequest {
+var Request2 = class extends GlobalRequest {
   constructor(input, options) {
     if (typeof input === "object" && getRequestCache in input) {
       input = input[getRequestCache]();
@@ -12213,7 +12213,7 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
   };
   if (method === "TRACE") {
     init.method = "GET";
-    const req = new Request(url, init);
+    const req = new Request2(url, init);
     Object.defineProperty(req, "method", {
       get() {
         return "TRACE";
@@ -12250,7 +12250,7 @@ var newRequestFromIncoming = (method, url, headers, incoming, abortController) =
       init.body = Readable.toWeb(incoming);
     }
   }
-  return new Request(url, init);
+  return new Request2(url, init);
 };
 var getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
 var requestCache = /* @__PURE__ */ Symbol("requestCache");
@@ -12311,7 +12311,7 @@ var requestPrototype = {
     }
   });
 });
-Object.setPrototypeOf(requestPrototype, Request.prototype);
+Object.setPrototypeOf(requestPrototype, Request2.prototype);
 var newRequest = (incoming, defaultHostname) => {
   const req = Object.create(requestPrototype);
   req[incomingKey] = incoming;
@@ -12622,9 +12622,9 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 };
 var getRequestListener = (fetchCallback, options = {}) => {
   const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-  if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+  if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
     Object.defineProperty(global, "Request", {
-      value: Request
+      value: Request2
     });
     Object.defineProperty(global, "Response", {
       value: Response2
@@ -13999,14 +13999,17 @@ var App = class {
     return this.resources;
   }
   /**
-   * Create a Vercel MCP adapter configuration.
-   * For use with Vercel's `mcp-handler` package.
+   * Create a Vercel serverless function handler.
+   * Works with plain Vercel Serverless Functions - no Next.js or mcp-handler needed.
    * 
-   * Note: This returns a configuration callback. The implementation
-   * is inline to avoid circular dependencies.
+   * Usage in api/mcp.ts:
+   * ```ts
+   * import { app } from "../src/app";
+   * export default app.toVercelFunctionHandler();
+   * ```
    */
-  toVercelMcp(options) {
-    return this.createServerlessConfig(options);
+  toVercelFunctionHandler(options) {
+    return this.createVercelHandler(options);
   }
   /**
    * Create an AWS Lambda handler.
@@ -14133,41 +14136,200 @@ var App = class {
     };
   }
   /**
-   * Create a Vercel MCP configuration callback.
-   * Returns a function compatible with Vercel's mcp-handler createMcpHandler.
+   * Create a Vercel serverless function handler.
+   * Handles MCP JSON-RPC protocol directly - no mcp-handler or Next.js needed.
    */
-  createServerlessConfig(options) {
+  createVercelHandler(options) {
     const { stateAdapter, realtimeAdapter } = options || {};
     const app = this;
-    return function mcpConfig(server, _context) {
-      for (const [name, definition] of app.tools) {
-        const { config: toolConfig, handler } = definition;
-        const inputSchema = toolConfig.input || z2.object({});
-        const hasUi = !!toolConfig.ui;
-        server.registerTool(
+    const corsHeaders = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Accept, Mcp-Session-Id",
+      "Content-Type": "application/json"
+    };
+    return async (reqOrRequest, res) => {
+      const isEdge = reqOrRequest instanceof Request;
+      if (isEdge ? reqOrRequest.method === "OPTIONS" : reqOrRequest.method === "OPTIONS") {
+        if (isEdge) {
+          return new Response(null, { status: 204, headers: corsHeaders });
+        }
+        res.status(204).end();
+        return;
+      }
+      let body = {};
+      try {
+        if (isEdge) {
+          body = await reqOrRequest.json();
+        } else if (reqOrRequest.body) {
+          body = typeof reqOrRequest.body === "string" ? JSON.parse(reqOrRequest.body) : reqOrRequest.body;
+        }
+      } catch {
+        const errorResponse = { jsonrpc: "2.0", error: { code: -32700, message: "Parse error" }, id: null };
+        if (isEdge) {
+          return new Response(JSON.stringify(errorResponse), { status: 400, headers: corsHeaders });
+        }
+        res.status(400).json(errorResponse);
+        return;
+      }
+      try {
+        const result = await app.handleMcpRequest(body, { stateAdapter, realtimeAdapter });
+        if (isEdge) {
+          return new Response(JSON.stringify(result), { status: 200, headers: corsHeaders });
+        }
+        res.status(200).json(result);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        const errorResponse = { jsonrpc: "2.0", error: { code: -32603, message: err.message }, id: body.id ?? null };
+        if (isEdge) {
+          return new Response(JSON.stringify(errorResponse), { status: 500, headers: corsHeaders });
+        }
+        res.status(500).json(errorResponse);
+      }
+    };
+  }
+  /**
+   * Handle an MCP JSON-RPC request.
+   * Shared logic for all serverless handlers.
+   */
+  async handleMcpRequest(body, options) {
+    const { stateAdapter, realtimeAdapter } = options;
+    const method = body.method;
+    const params = body.params;
+    const id = body.id;
+    if (method === "initialize") {
+      return {
+        jsonrpc: "2.0",
+        result: {
+          protocolVersion: "2024-11-05",
+          serverInfo: { name: this.config.name, version: this.config.version },
+          capabilities: { tools: {}, resources: {} },
+          ...this.config.instructions && { instructions: this.config.instructions }
+        },
+        id
+      };
+    }
+    if (method === "tools/list") {
+      const tools = [];
+      for (const [name, definition] of this.tools) {
+        const { config } = definition;
+        const toolMeta = this.buildToolMeta(config);
+        tools.push({
           name,
-          {
-            title: name,
-            description: toolConfig.description + (hasUi ? " Returns instanceId for the widget." : ""),
-            inputSchema
+          description: this.buildToolDescription(config, config.input || z2.object({})),
+          inputSchema: config.input ? this.zodToJsonSchema(config.input) : { type: "object" },
+          ...Object.keys(toolMeta).length > 0 && { _meta: toolMeta }
+        });
+      }
+      return { jsonrpc: "2.0", result: { tools }, id };
+    }
+    if (method === "tools/call") {
+      const toolName = params?.name;
+      const args = params?.arguments || {};
+      const definition = this.tools.get(toolName);
+      if (!definition) {
+        return { jsonrpc: "2.0", error: { code: -32601, message: `Tool not found: ${toolName}` }, id };
+      }
+      const { config: toolConfig, handler } = definition;
+      const creatureToken = args._creatureToken;
+      const { _creatureToken: _, ...cleanArgs } = args;
+      const input = toolConfig.input ? toolConfig.input.parse(cleanArgs) : cleanArgs;
+      const instanceId = cleanArgs.instanceId || this.generateInstanceId();
+      const context = this.createServerlessContext({ instanceId, creatureToken, stateAdapter, realtimeAdapter });
+      const result = await handler(input, context);
+      const formatted = this.formatServerlessResult(result, instanceId, context.websocketUrl);
+      return { jsonrpc: "2.0", result: formatted, id };
+    }
+    if (method === "resources/list") {
+      const resources = [];
+      for (const [uri, { config }] of this.resources) {
+        resources.push({
+          uri,
+          name: config.name,
+          description: config.description,
+          mimeType: MIME_TYPES.MCP_APPS
+        });
+      }
+      return { jsonrpc: "2.0", result: { resources }, id };
+    }
+    if (method === "resources/read") {
+      const uri = params?.uri;
+      const resourceDef = this.resources.get(uri);
+      if (!resourceDef) {
+        return { jsonrpc: "2.0", error: { code: -32601, message: `Resource not found: ${uri}` }, id };
+      }
+      const { config } = resourceDef;
+      let html = typeof config.html === "function" ? await config.html() : config.html;
+      const mcpAppsMeta = {
+        ui: {
+          displayModes: config.displayModes,
+          ...config.icon && {
+            icon: {
+              data: svgToDataUri(config.icon.svg),
+              alt: config.icon.alt
+            }
           },
-          async (args) => {
-            try {
-              const creatureToken = args._creatureToken;
-              const { _creatureToken: _, ...cleanArgs } = args;
-              const input = toolConfig.input ? toolConfig.input.parse(cleanArgs) : cleanArgs;
-              const instanceId = cleanArgs.instanceId || app.generateInstanceId();
-              const context = app.createServerlessContext({ instanceId, creatureToken, stateAdapter, realtimeAdapter });
-              const result = await handler(input, context);
-              return app.formatServerlessResult(result, instanceId, context.websocketUrl);
-            } catch (error) {
-              const err = error instanceof Error ? error : new Error(String(error));
-              return { content: [{ type: "text", text: err.message }], isError: true };
+          ...config.csp && { csp: config.csp }
+        },
+        "openai/widgetPrefersBorder": true
+      };
+      return {
+        jsonrpc: "2.0",
+        result: {
+          contents: [
+            {
+              uri,
+              mimeType: MIME_TYPES.MCP_APPS,
+              text: html,
+              _meta: mcpAppsMeta
+            }
+          ]
+        },
+        id
+      };
+    }
+    return { jsonrpc: "2.0", error: { code: -32601, message: `Method not found: ${method}` }, id };
+  }
+  /**
+   * Convert Zod schema to JSON Schema for tool definitions.
+   */
+  zodToJsonSchema(schema) {
+    if ("_def" in schema) {
+      const def = schema._def;
+      if (def.typeName === "ZodObject") {
+        const shape = def.shape?.() || {};
+        const properties = {};
+        const required = [];
+        for (const [key, value] of Object.entries(shape)) {
+          const fieldDef = value._def;
+          if (fieldDef?.typeName === "ZodString") {
+            properties[key] = { type: "string", description: fieldDef.description };
+          } else if (fieldDef?.typeName === "ZodNumber") {
+            properties[key] = { type: "number", description: fieldDef.description };
+          } else if (fieldDef?.typeName === "ZodBoolean") {
+            properties[key] = { type: "boolean", description: fieldDef.description };
+          } else if (fieldDef?.typeName === "ZodOptional") {
+            const inner = fieldDef.innerType?._def;
+            if (inner?.typeName === "ZodString") {
+              properties[key] = { type: "string", description: inner.description };
+            } else {
+              properties[key] = { type: "string" };
             }
+          } else {
+            properties[key] = { type: "string" };
           }
-        );
+          if (fieldDef?.typeName !== "ZodOptional") {
+            required.push(key);
+          }
+        }
+        return {
+          type: "object",
+          properties,
+          ...required.length > 0 && { required }
+        };
       }
-    };
+    }
+    return { type: "object" };
   }
   /**
    * Create an AWS Lambda handler function.
@@ -14175,13 +14337,13 @@ var App = class {
   createLambdaHandler(options) {
     const { stateAdapter, realtimeAdapter } = options || {};
     const app = this;
+    const corsHeaders = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Accept, Mcp-Session-Id",
+      "Content-Type": "application/json"
+    };
     return async (event, _lambdaContext) => {
-      const corsHeaders = {
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type, Accept, Mcp-Session-Id",
-        "Content-Type": "application/json"
-      };
       if (event.httpMethod === "OPTIONS") {
         return { statusCode: 204, headers: corsHeaders, body: "" };
       }
@@ -14200,68 +14362,11 @@ var App = class {
         }
       }
       try {
-        const method = body.method;
-        const params = body.params;
-        const id = body.id;
-        if (method === "initialize") {
-          return {
-            statusCode: 200,
-            headers: corsHeaders,
-            body: JSON.stringify({
-              jsonrpc: "2.0",
-              result: {
-                protocolVersion: "2024-11-05",
-                serverInfo: { name: app.config.name, version: app.config.version },
-                capabilities: { tools: {}, resources: {} }
-              },
-              id
-            })
-          };
-        }
-        if (method === "tools/list") {
-          const tools = [];
-          for (const [name, definition] of app.tools) {
-            tools.push({
-              name,
-              description: definition.config.description,
-              inputSchema: { type: "object" }
-            });
-          }
-          return {
-            statusCode: 200,
-            headers: corsHeaders,
-            body: JSON.stringify({ jsonrpc: "2.0", result: { tools }, id })
-          };
-        }
-        if (method === "tools/call") {
-          const toolName = params?.name;
-          const args = params?.arguments || {};
-          const definition = app.tools.get(toolName);
-          if (!definition) {
-            return {
-              statusCode: 200,
-              headers: corsHeaders,
-              body: JSON.stringify({ jsonrpc: "2.0", error: { code: -32601, message: `Tool not found: ${toolName}` }, id })
-            };
-          }
-          const { config: toolConfig, handler } = definition;
-          const creatureToken = args._creatureToken;
-          const { _creatureToken: _, ...cleanArgs } = args;
-          const input = toolConfig.input ? toolConfig.input.parse(cleanArgs) : cleanArgs;
-          const instanceId = cleanArgs.instanceId || app.generateInstanceId();
-          const context = app.createServerlessContext({ instanceId, creatureToken, stateAdapter, realtimeAdapter });
-          const result = await handler(input, context);
-          const formatted = app.formatServerlessResult(result, instanceId, context.websocketUrl);
-          return {
-            statusCode: 200,
-            headers: corsHeaders,
-            body: JSON.stringify({ jsonrpc: "2.0", result: formatted, id })
-          };
-        }
+        const result = await app.handleMcpRequest(body, { stateAdapter, realtimeAdapter });
         return {
           statusCode: 200,
           headers: corsHeaders,
-          body: JSON.stringify({ jsonrpc: "2.0", error: { code: -32601, message: `Method not found: ${method}` }, id })
+          body: JSON.stringify(result)
         };
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));