chore(internal): fix MCP cloudflare worker initialization

Author: stainless-app[bot]

packages/mcp-server/cloudflare-worker/src/index.ts

@@ -6,10 +6,12 @@ import { makeOAuthConsent } from './app';
 // `instanceof McpServer` check fails because the two `McpServer` classes are
 // distinct constructors.
 import { McpAgent } from 'agents/mcp';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import OAuthProvider from '@cloudflare/workers-oauth-provider';
 import { ClientOptions } from '@imagekit/nodejs';
 import { McpOptions } from '@imagekit/api-mcp/options';
 import { initMcpServer, newMcpServer } from '@imagekit/api-mcp/server';
+import { configureLogger } from '@imagekit/api-mcp/logger';
 import type { ExportedHandler } from '@cloudflare/workers-types';
 
 type MCPProps = {
@@ -58,19 +60,74 @@ const serverConfig: ServerConfig = {
   ],
 };
 
+// `newMcpServer` fetches MCP server instructions from the Stainless API. In a
+// Durable Object, that fetch happens inside `blockConcurrencyWhile`; if it
+// hangs the DO is reset, and if it rejects the same thing happens. Race
+// against a short timeout and catch any rejection so any failure mode lands
+// on a fallback server constructed without instructions (the `initialize`
+// response simply omits the `instructions` field, which is spec-allowed).
+const INSTRUCTIONS_FETCH_TIMEOUT_MS = 5000;
+
+function fallbackMcpServer(): McpServer {
+  return new McpServer(
+    { name: 'imagekit_nodejs_api', version: '7.5.0' },
+    { capabilities: { tools: {}, logging: {} } },
+  );
+}
+
+async function buildMcpServer(stainlessApiKey?: string): Promise<McpServer> {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const fetched = newMcpServer({ stainlessApiKey });
+    const timeout = new Promise<null>((resolve) => {
+      timeoutId = setTimeout(() => resolve(null), INSTRUCTIONS_FETCH_TIMEOUT_MS);
+    });
+
+    const result = await Promise.race([fetched, timeout]);
+
+    if (result != null) {
+      return result;
+    }
+  } catch (error) {
+    console.error('Failed to build MCP server from upstream instructions; using fallback', error);
+  } finally {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  return fallbackMcpServer();
+}
+
 export class MyMCP extends McpAgent<Env, unknown, MCPProps> {
-  server = newMcpServer({});
+  #resolveServer!: (server: McpServer) => void;
+  #rejectServer!: (error: unknown) => void;
+  server: Promise<McpServer> = new Promise<McpServer>((resolve, reject) => {
+    this.#resolveServer = resolve;
+    this.#rejectServer = reject;
+  });
 
   async init() {
-    if (this.props == null) {
-      throw new Error('MCP props are not initialized');
-    }
+    try {
+      if (this.props == null) {
+        throw new Error('MCP props are not initialized');
+      }
 
-    initMcpServer({
-      server: await this.server,
-      clientOptions: this.props.clientProps,
-      mcpOptions: this.props.clientConfig,
-    });
+      configureLogger({ level: 'info', pretty: false });
+
+      const server = await buildMcpServer(this.props.clientConfig?.stainlessApiKey);
+
+      await initMcpServer({
+        server,
+        clientOptions: this.props.clientProps,
+        mcpOptions: this.props.clientConfig,
+      });
+
+      this.#resolveServer(server);
+    } catch (error) {
+      this.#rejectServer(error);
+      throw error;
+    }
   }
 }