ci: add workflow_dispatch trigger to generate

Stainless-Generated-From: 1c60f594a092b548667fb71265c5650dc4bc8c65

Author: stlc-bot

packages/mcp-server/src/code-tool.ts

@@ -6,6 +6,7 @@ import { WorkerOutput } from './code-tool-types';
 import { getLogger } from './logger';
 import { SdkMethod } from './methods';
 import { McpCodeExecutionMode } from './options';
+import { remoteSandboxHandler } from './remote-sandbox-handler';
 import { ClientOptions } from '@coingecko/coingecko-typescript';
 
 const prompt = `Runs JavaScript code to interact with the Coingecko API.
@@ -39,14 +40,21 @@ Always type dynamic key-value stores explicitly as Record<string, YourValueType>
  * matching, so it is not secure against obfuscation. For stronger security, block in the downstream API
  * with limited API keys.
  * @param codeExecutionMode - Whether to execute code in a local Deno environment or in a remote
- * sandbox environment hosted by Stainless.
+ * sandbox (see remote-sandbox-handler.ts).
+ * @param sandboxEndpoint - URL of the remote sandbox's code-tool endpoint ('remote-sandbox' mode only).
+ * @param sandboxFetcher - Optional fetch used to reach the sandbox, e.g. a Cloudflare service-binding
+ * fetch. Defaults to global fetch.
  */
 export function codeTool({
   blockedMethods,
   codeExecutionMode,
+  sandboxEndpoint,
+  sandboxFetcher,
 }: {
   blockedMethods: SdkMethod[] | undefined;
   codeExecutionMode: McpCodeExecutionMode;
+  sandboxEndpoint?: string | undefined;
+  sandboxFetcher?: typeof fetch | undefined;
 }): McpTool {
   const metadata: Metadata = { resource: 'all', operation: 'write', tags: [] };
   const tool: Tool = {
@@ -100,8 +108,18 @@ export function codeTool({
     let result: ToolCallResult;
     const startTime = Date.now();
 
-    logger.debug('Executing code in local Deno environment');
-    result = await localDenoHandler({ reqContext, args });
+    if (codeExecutionMode === 'remote-sandbox') {
+      logger.debug('Executing code in remote sandbox');
+      result = await remoteSandboxHandler({
+        reqContext,
+        args,
+        endpoint: sandboxEndpoint,
+        fetcher: sandboxFetcher,
+      });
+    } else {
+      logger.debug('Executing code in local Deno environment');
+      result = await localDenoHandler({ reqContext, args });
+    }
 
     logger.info(
       {

packages/mcp-server/src/options.ts

@@ -24,10 +24,12 @@ export type McpOptions = {
   codeAllowedMethods?: string[] | undefined;
   codeBlockedMethods?: string[] | undefined;
   codeExecutionMode: McpCodeExecutionMode;
+  sandboxEndpoint?: string | undefined;
+  sandboxFetcher?: typeof fetch | undefined;
   customInstructionsPath?: string | undefined;
 };
 
-export type McpCodeExecutionMode = 'local';
+export type McpCodeExecutionMode = 'local' | 'remote-sandbox';
 
 export function parseCLIOptions(): CLIOptions {
   const opts = yargs(hideBin(process.argv))

packages/mcp-server/src/remote-sandbox-handler.ts

@@ -0,0 +1,85 @@
+// Custom code — not generated. Do not remove during regeneration.
+//
+// Runs the `execute` tool in a remote sandbox (coingecko/coingecko-mcp-sandbox)
+// instead of a local Deno subprocess. Serverless runtimes like Cloudflare
+// Workers cannot spawn subprocesses, so hosted deployments must use this mode.
+//
+// Wire contract (matches what coingecko-mcp-sandbox serves):
+//   POST <endpoint>
+//     headers: x-stainless-mcp-client-envs: JSON of env vars for the sandboxed SDK client
+//     body:    { project_name, code, intent, client_opts }
+//   response: { is_error, result, log_lines, err_lines }
+
+import { McpRequestContext, ToolCallResult, asErrorResult, asTextContentResult } from './types';
+import { WorkerInput, WorkerOutput } from './code-tool-types';
+import { readEnv } from './util';
+
+export const remoteSandboxHandler = async ({
+  reqContext,
+  args,
+  endpoint,
+  fetcher,
+}: {
+  reqContext: McpRequestContext;
+  args: any;
+  endpoint: string | undefined;
+  fetcher?: typeof fetch | undefined;
+}): Promise<ToolCallResult> => {
+  if (!endpoint) {
+    return asErrorResult(
+      "Code execution mode 'remote-sandbox' requires a sandbox endpoint. Set the sandboxEndpoint MCP option.",
+    );
+  }
+
+  const code = args.code as string;
+  const intent = args.intent as string | undefined;
+  const client = reqContext.client;
+  const environment = readEnv('COINGECKO_ENVIRONMENT') || undefined;
+
+  // Credentials and base URL for the SDK client that runs inside the sandbox.
+  // When a base URL or environment is configured via env vars, the sandbox
+  // resolves the URL itself; otherwise forward this client's configured baseURL.
+  const clientEnvs = {
+    COINGECKO_PRO_API_KEY: readEnv('COINGECKO_PRO_API_KEY') ?? client.proAPIKey ?? undefined,
+    COINGECKO_DEMO_API_KEY: readEnv('COINGECKO_DEMO_API_KEY') ?? client.demoAPIKey ?? undefined,
+    COINGECKO_BASE_URL:
+      readEnv('COINGECKO_BASE_URL') ?? environment ? undefined : client.baseURL ?? undefined,
+  };
+  // Env vars forwarded by an upstream proxy (request header) take precedence.
+  const mergedClientEnvs = { ...clientEnvs, ...reqContext.upstreamClientEnvs };
+
+  const doFetch = fetcher ?? fetch;
+  const res = await doFetch(endpoint, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'x-stainless-mcp-client-envs': JSON.stringify(mergedClientEnvs),
+    },
+    body: JSON.stringify({
+      project_name: 'coingecko',
+      code,
+      intent,
+      client_opts: { environment: environment as any },
+    } satisfies WorkerInput),
+  });
+
+  if (!res.ok) {
+    throw new Error(
+      `${res.status}: ${
+        res.statusText
+      } error when trying to contact the code execution sandbox. Details: ${await res.text()}`,
+    );
+  }
+
+  const { is_error, result, log_lines, err_lines } = (await res.json()) as WorkerOutput;
+  const hasLogs = log_lines.length > 0 || err_lines.length > 0;
+  const output = {
+    result,
+    ...(log_lines.length > 0 && { log_lines }),
+    ...(err_lines.length > 0 && { err_lines }),
+  };
+  if (is_error) {
+    return asErrorResult(typeof result === 'string' && !hasLogs ? result : JSON.stringify(output, null, 2));
+  }
+  return asTextContentResult(output);
+};

packages/mcp-server/src/server.ts

@@ -185,6 +185,8 @@ export function selectTools(options?: McpOptions): McpTool[] {
       codeTool({
         blockedMethods: blockedMethodsForCodeTool(options),
         codeExecutionMode: options?.codeExecutionMode ?? 'local',
+        sandboxEndpoint: options?.sandboxEndpoint,
+        sandboxFetcher: options?.sandboxFetcher,
       }),
     );
   }