integrate-sdk 0.9.2-dev.0 → 0.9.4-dev.0

package/dist/ai/openai.d.ts

@@ -31,6 +31,17 @@ export interface OpenAIToolsOptions extends AIToolsOptions {
     strict?: boolean;
     /** User context for multi-tenant token storage */
     context?: MCPContext;
+    /**
+     * How to expose MCP tools to the model.
+     *
+     * - `'code'` (default): Returns a single `execute_code` tool backed by a
+     *   Vercel Sandbox. The model writes TypeScript that calls the typed
+     *   `client.<integration>.<method>()` API and chains operations in one round-trip.
+     * - `'tools'`: Legacy behavior — one OpenAI function tool per MCP tool.
+     *
+     * @default 'code'
+     */
+    mode?: 'code' | 'tools';
 }
 /**
  * Get tools in a format compatible with OpenAI Responses API

package/dist/ai/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/ai/openai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GAAG,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CA8CvB;AAwFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,EAChE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAyB3H"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../src/ai/openai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAkE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAIjH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QACV,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,GAAG,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,cAAc;IACxD;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB;;;;;;;;;OASG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AAiCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,UAAU,EAAE,CAAC,CAgEvB;AA0GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,QAAQ,EAAE;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,EAChE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC,kBAAkB,EAAE,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAA,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAyB3H"}

package/dist/ai/openai.js

@@ -4402,6 +4402,523 @@ function createTriggerTools(config, context) {
   };
 }
 
+// ../utils/naming.ts
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toolNameToMethod(toolName) {
+  const withoutPrefix = toolName.replace(/^[^_]+_/, "");
+  return snakeToCamel(withoutPrefix);
+}
+
+// ../code-mode/type-generator.ts
+var RESERVED_TS = new Set([
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "new",
+  "null",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "as",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield"
+]);
+function safeIdent(name) {
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) || RESERVED_TS.has(name)) {
+    return JSON.stringify(name);
+  }
+  return name;
+}
+function integrationFromToolName(toolName) {
+  const idx = toolName.indexOf("_");
+  return idx === -1 ? toolName : toolName.slice(0, idx);
+}
+function jsonSchemaToTs(schema, indent) {
+  if (!schema || typeof schema !== "object")
+    return "unknown";
+  const s = schema;
+  if (Array.isArray(s.enum) && s.enum.length > 0) {
+    return s.enum.map((v) => typeof v === "string" ? JSON.stringify(v) : typeof v === "number" || typeof v === "boolean" ? String(v) : "unknown").join(" | ");
+  }
+  if (Array.isArray(s.type)) {
+    return s.type.map((t2) => jsonSchemaToTs({ ...s, type: t2 }, indent)).join(" | ");
+  }
+  const t = s.type;
+  switch (t) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array": {
+      const items = s.items;
+      if (Array.isArray(items))
+        return "unknown[]";
+      const inner = jsonSchemaToTs(items, indent);
+      return /[|&]/.test(inner) ? `Array<${inner}>` : `${inner}[]`;
+    }
+    case "object":
+      return objectShape(s, indent);
+    default:
+      if (s.properties && typeof s.properties === "object")
+        return objectShape(s, indent);
+      return "unknown";
+  }
+}
+function objectShape(schema, indent) {
+  const props = schema.properties && typeof schema.properties === "object" ? schema.properties : {};
+  const keys = Object.keys(props);
+  if (keys.length === 0) {
+    return schema.additionalProperties === false ? "Record<string, never>" : "Record<string, unknown>";
+  }
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  const inner = indent + "  ";
+  const lines = ["{"];
+  for (const key of keys) {
+    const prop = props[key];
+    const desc = prop && typeof prop.description === "string" ? prop.description : undefined;
+    if (desc)
+      lines.push(`${inner}/** ${desc.replace(/\*\//g, "*\\/")} */`);
+    const optional = required.has(key) ? "" : "?";
+    const type = jsonSchemaToTs(prop, inner);
+    lines.push(`${inner}${safeIdent(key)}${optional}: ${type};`);
+  }
+  lines.push(`${indent}}`);
+  return lines.join(`
+`);
+}
+function argsType(schema) {
+  if (!schema)
+    return "Record<string, unknown>";
+  const hasProps = schema.properties && Object.keys(schema.properties).length > 0;
+  if (!hasProps)
+    return "Record<string, unknown>";
+  return objectShape(schema, "  ");
+}
+function methodHasRequiredArgs(schema) {
+  if (!schema || !schema.properties)
+    return false;
+  const req = Array.isArray(schema.required) ? schema.required : [];
+  return req.length > 0;
+}
+function formatDescription(desc, indent) {
+  if (!desc)
+    return "";
+  const cleaned = desc.replace(/\*\//g, "*\\/").trim();
+  if (!cleaned.includes(`
+`))
+    return `${indent}/** ${cleaned} */
+`;
+  const lines = cleaned.split(`
+`).map((l) => `${indent} * ${l}`).join(`
+`);
+  return `${indent}/**
+${lines}
+${indent} */
+`;
+}
+function generateCodeModeTypes(tools) {
+  const byIntegration = {};
+  for (const tool of tools) {
+    const integration = integrationFromToolName(tool.name);
+    (byIntegration[integration] ??= []).push(tool);
+  }
+  const methodMap = {};
+  const integrationCounts = {};
+  const sections = [];
+  const integrationIds = Object.keys(byIntegration).sort();
+  sections.push("/**");
+  sections.push(" * Integrate SDK — available APIs inside `execute_code`.");
+  sections.push(" * Every method is async and returns the MCP tool-call response.");
+  sections.push(" * Call them via the exported `client` object, e.g.");
+  sections.push(" *   const repos = await client.github.listRepos();");
+  sections.push(" */");
+  sections.push("");
+  for (const integrationId of integrationIds) {
+    const integrationTools = byIntegration[integrationId].slice().sort((a, b) => a.name.localeCompare(b.name));
+    integrationCounts[integrationId] = integrationTools.length;
+    const interfaceName = pascalCase(integrationId) + "Client";
+    sections.push(`export interface ${interfaceName} {`);
+    for (const tool of integrationTools) {
+      const methodName = toolNameToMethod(tool.name);
+      methodMap[`${integrationId}.${methodName}`] = tool.name;
+      sections.push(formatDescription(tool.description, "  "));
+      const argType = argsType(tool.inputSchema);
+      const argIsOptional = !methodHasRequiredArgs(tool.inputSchema);
+      const paramName = argIsOptional ? "args?" : "args";
+      sections.push(`  ${safeIdent(methodName)}(${paramName}: ${argType}): Promise<ToolResult>;`);
+    }
+    sections.push("}");
+    sections.push("");
+  }
+  sections.push("export interface ToolResult {");
+  sections.push("  content: Array<{ type: 'text' | 'image' | 'resource'; text?: string; data?: string; mimeType?: string; [key: string]: unknown }>;");
+  sections.push("  isError?: boolean;");
+  sections.push("  structuredContent?: Record<string, unknown>;");
+  sections.push("}");
+  sections.push("");
+  sections.push("export interface Client {");
+  for (const integrationId of integrationIds) {
+    const interfaceName = pascalCase(integrationId) + "Client";
+    sections.push(`  ${safeIdent(integrationId)}: ${interfaceName};`);
+  }
+  sections.push("}");
+  sections.push("");
+  sections.push("export declare const client: Client;");
+  return {
+    source: sections.filter((line, idx, arr) => !(line === "" && arr[idx - 1] === "")).join(`
+`),
+    methodMap,
+    integrationCounts
+  };
+}
+function pascalCase(id) {
+  return id.split(/[^A-Za-z0-9]/).filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("") || "Unknown";
+}
+
+// ../code-mode/runtime-stub.ts
+var RUNTIME_STUB_SOURCE = `// runtime.mjs — generated by integrate-sdk code mode
+const MCP_URL = process.env.INTEGRATE_MCP_URL;
+const SESSION_TOKEN = process.env.INTEGRATE_SESSION_TOKEN;
+const PROVIDER_TOKENS = process.env.INTEGRATE_PROVIDER_TOKENS || '';
+const INTEGRATIONS_HEADER = process.env.INTEGRATE_INTEGRATIONS || '';
+const CONTEXT_JSON = process.env.INTEGRATE_CONTEXT || '';
+
+if (!MCP_URL) {
+  throw new Error('INTEGRATE_MCP_URL is not set — the sandbox cannot reach the MCP route.');
+}
+
+function camelToSnake(str) {
+  return str.replace(/[A-Z]/g, (letter) => '_' + letter.toLowerCase());
+}
+
+async function callTool(toolName, args) {
+  const headers = {
+    'Content-Type': 'application/json',
+    'x-integrate-code-mode': '1',
+  };
+  if (SESSION_TOKEN) headers['Authorization'] = 'Bearer ' + SESSION_TOKEN;
+  if (PROVIDER_TOKENS) headers['x-integrate-tokens'] = PROVIDER_TOKENS;
+  if (INTEGRATIONS_HEADER) headers['x-integrations'] = INTEGRATIONS_HEADER;
+  if (CONTEXT_JSON) headers['x-integrate-context'] = CONTEXT_JSON;
+
+  const res = await fetch(MCP_URL, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ name: toolName, arguments: args || {} }),
+  });
+
+  const text = await res.text();
+  let payload;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { content: [{ type: 'text', text }] };
+  }
+
+  if (!res.ok) {
+    const message = (payload && (payload.error || payload.message)) || 'Tool call failed: HTTP ' + res.status;
+    const err = new Error(message);
+    err.status = res.status;
+    err.toolName = toolName;
+    throw err;
+  }
+
+  return payload;
+}
+
+function createIntegrationProxy(integrationId) {
+  return new Proxy({}, {
+    get(_target, methodName) {
+      if (typeof methodName !== 'string') return undefined;
+      return (args) => callTool(integrationId + '_' + camelToSnake(methodName), args);
+    },
+  });
+}
+
+export const client = new Proxy({}, {
+  get(_target, integrationId) {
+    if (typeof integrationId !== 'string') return undefined;
+    return createIntegrationProxy(integrationId);
+  },
+});
+
+export { callTool };
+`;
+
+// ../code-mode/executor.ts
+var sandboxFactoryOverride = null;
+async function loadSandboxFactory() {
+  if (sandboxFactoryOverride)
+    return sandboxFactoryOverride;
+  try {
+    const dynamicImport = new Function("specifier", "return import(specifier)");
+    const pkg = "@" + "vercel/sandbox";
+    const mod = await dynamicImport(pkg);
+    return mod.Sandbox ?? mod.default?.Sandbox ?? mod;
+  } catch (err) {
+    throw new Error("Code Mode requires the optional peer dependency `@vercel/sandbox`. " + "Install it with `npm install @vercel/sandbox` (or `bun add @vercel/sandbox`).");
+  }
+}
+var RESULT_SENTINEL = "__INTEGRATE_RESULT__";
+function wrapUserCode(code) {
+  return `// user.mjs — wrapped by integrate-sdk code mode
+import { client, callTool } from './runtime.mjs';
+
+(async () => {
+  try {
+    const __result = await (async () => {
+${code}
+    })();
+    if (typeof __result !== 'undefined') {
+      process.stdout.write('\\n' + ${JSON.stringify(RESULT_SENTINEL)} + JSON.stringify(__result) + '\\n');
+    }
+  } catch (err) {
+    const payload = {
+      message: err && err.message ? err.message : String(err),
+      name: err && err.name,
+      stack: err && err.stack,
+      toolName: err && err.toolName,
+      status: err && err.status,
+    };
+    process.stderr.write('\\n' + ${JSON.stringify(RESULT_SENTINEL)} + JSON.stringify({ error: payload }) + '\\n');
+    process.exit(1);
+  }
+})();
+`;
+}
+function defaultNetworkPolicy(mcpUrl) {
+  try {
+    const host = new URL(mcpUrl).hostname;
+    return { allow: [host] };
+  } catch {
+    return { allow: [] };
+  }
+}
+function extractResult(stream) {
+  const idx = stream.lastIndexOf(RESULT_SENTINEL);
+  if (idx === -1)
+    return { cleaned: stream };
+  const before = stream.slice(0, idx).replace(/\n$/, "");
+  const rest = stream.slice(idx + RESULT_SENTINEL.length);
+  const newlineIdx = rest.indexOf(`
+`);
+  const payload = newlineIdx === -1 ? rest : rest.slice(0, newlineIdx);
+  const after = newlineIdx === -1 ? "" : rest.slice(newlineIdx + 1);
+  try {
+    return { cleaned: (before + after).trimEnd(), result: JSON.parse(payload) };
+  } catch {
+    return { cleaned: stream };
+  }
+}
+async function executeSandboxCode(options) {
+  const startedAt = Date.now();
+  const runtime = options.runtime ?? "node22";
+  const timeoutMs = options.timeoutMs ?? 60000;
+  const networkPolicy = options.networkPolicy ?? defaultNetworkPolicy(options.mcpUrl);
+  let sandbox = null;
+  try {
+    const Sandbox = await loadSandboxFactory();
+    sandbox = await Sandbox.create({
+      runtime,
+      timeout: timeoutMs,
+      resources: options.vcpus ? { vcpus: options.vcpus } : undefined,
+      networkPolicy
+    });
+    const runtimeContent = Buffer.from(RUNTIME_STUB_SOURCE, "utf-8");
+    const userContent = Buffer.from(wrapUserCode(options.code), "utf-8");
+    await sandbox.writeFiles([
+      { path: "runtime.mjs", content: runtimeContent },
+      { path: "user.mjs", content: userContent }
+    ]);
+    const env = {
+      INTEGRATE_MCP_URL: options.mcpUrl
+    };
+    if (options.sessionToken)
+      env.INTEGRATE_SESSION_TOKEN = options.sessionToken;
+    if (options.providerTokens && Object.keys(options.providerTokens).length > 0) {
+      env.INTEGRATE_PROVIDER_TOKENS = JSON.stringify(options.providerTokens);
+    }
+    if (options.integrationsHeader)
+      env.INTEGRATE_INTEGRATIONS = options.integrationsHeader;
+    if (options.context)
+      env.INTEGRATE_CONTEXT = JSON.stringify(options.context);
+    const cmd = await sandbox.runCommand({
+      cmd: "node",
+      args: ["user.mjs"],
+      env
+    });
+    const [stdoutRaw, stderrRaw] = await Promise.all([cmd.stdout(), cmd.stderr()]);
+    const stdoutExtract = extractResult(stdoutRaw);
+    const stderrExtract = extractResult(stderrRaw);
+    return {
+      success: cmd.exitCode === 0,
+      exitCode: cmd.exitCode,
+      result: stdoutExtract.result ?? stderrExtract.result,
+      stdout: stdoutExtract.cleaned,
+      stderr: stderrExtract.cleaned,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (err) {
+    return {
+      success: false,
+      exitCode: -1,
+      stdout: "",
+      stderr: "",
+      durationMs: Date.now() - startedAt,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    if (sandbox) {
+      try {
+        await sandbox.stop();
+      } catch {}
+    }
+  }
+}
+
+// ../utils/env.ts
+function getEnv(key) {
+  try {
+    const getImportMeta = new Function('return typeof import.meta !== "undefined" ? import.meta : undefined');
+    const importMeta = getImportMeta();
+    if (importMeta && typeof importMeta.env === "object" && importMeta.env !== null) {
+      const value = importMeta.env[key];
+      if (value !== undefined && value !== null && value !== "") {
+        return String(value);
+      }
+    }
+  } catch {}
+  if (typeof process !== "undefined" && process.env) {
+    const value = process.env[key];
+    if (value !== undefined && value !== null && value !== "") {
+      return value;
+    }
+  }
+  return;
+}
+
+// ../code-mode/tool-builder.ts
+var CODE_MODE_TOOL_NAME = "execute_code";
+var DEFAULT_INSTRUCTIONS = [
+  "You are given a single tool: `execute_code`. Instead of calling individual MCP tools,",
+  "you write a short async TypeScript/JavaScript snippet that uses the typed `client`",
+  "object below, and the snippet runs in an isolated sandbox which dispatches the actual",
+  "tool calls. Chain multiple operations together in one snippet whenever possible —",
+  "that is the whole point of this tool.",
+  "",
+  "Rules:",
+  "- The snippet is the body of an `async` function. Use `await` freely.",
+  "- Use `return <value>` at the end to hand a structured result back to the caller;",
+  "  the caller receives it as JSON.",
+  "- Use `console.log(...)` for intermediate observations you want to read later.",
+  "- Throw / let errors propagate; the runtime will surface them with a non-zero exit.",
+  "- Each method call returns an object of shape `ToolResult` (see types below).",
+  "  The payload usually lives in `result.content[0].text` as JSON — parse it if needed.",
+  "- You cannot import npm packages. Only the pre-imported `client` and standard",
+  "  globals (`fetch`, `console`, `JSON`, ...) are available.",
+  "",
+  "API surface:"
+].join(`
+`);
+function resolveCodeModeClientConfig(client) {
+  const oauthConfig = client.__oauthConfig;
+  return oauthConfig?.codeMode ?? {};
+}
+function buildCodeModeTool(client, options) {
+  const { tools, providerTokens, context, integrationIds } = options;
+  const generated = generateCodeModeTypes(tools);
+  const serverCodeModeConfig = resolveCodeModeClientConfig(client);
+  const sandboxOverrides = options.sandbox ?? {};
+  const description = `${DEFAULT_INSTRUCTIONS}
+
+\`\`\`typescript
+${generated.source}
+\`\`\``;
+  const execute = async ({ code }) => {
+    const publicUrl = sandboxOverrides.publicUrl ?? serverCodeModeConfig.publicUrl ?? getEnv("INTEGRATE_PUBLIC_URL");
+    if (!publicUrl) {
+      return {
+        success: false,
+        exitCode: -1,
+        stdout: "",
+        stderr: "",
+        durationMs: 0,
+        error: "Code Mode requires `codeMode.publicUrl` in createMCPServer config (or the INTEGRATE_PUBLIC_URL env var). " + "The sandbox uses it to call back into /api/integrate/mcp."
+      };
+    }
+    const mcpUrl = publicUrl.replace(/\/$/, "") + "/api/integrate/mcp";
+    return executeSandboxCode({
+      code,
+      mcpUrl,
+      providerTokens,
+      context,
+      integrationsHeader: integrationIds && integrationIds.length > 0 ? integrationIds.join(",") : undefined,
+      runtime: sandboxOverrides.runtime ?? serverCodeModeConfig.runtime,
+      timeoutMs: sandboxOverrides.timeoutMs ?? serverCodeModeConfig.timeoutMs,
+      vcpus: sandboxOverrides.vcpus ?? serverCodeModeConfig.vcpus,
+      networkPolicy: sandboxOverrides.networkPolicy ?? serverCodeModeConfig.networkPolicy
+    });
+  };
+  return {
+    name: CODE_MODE_TOOL_NAME,
+    description,
+    parameters: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "The TypeScript/JavaScript snippet to execute. It is wrapped in an async IIFE, so you may use top-level await and return a final value."
+        }
+      },
+      required: ["code"],
+      additionalProperties: false
+    },
+    execute
+  };
+}
+
 // openai.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
 function convertMCPToolToOpenAI(mcpTool, _client, options) {
@@ -4424,7 +4941,22 @@ async function getOpenAITools(client, options) {
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   await ensureClientConnected(client);
   const mcpTools = await client.getEnabledToolsAsync();
-  const openaiTools = mcpTools.map((mcpTool) => convertMCPToolToOpenAI(mcpTool, client, finalOptions));
+  const mode = options?.mode ?? "code";
+  const openaiTools = mode === "code" ? (() => {
+    const codeTool = buildCodeModeTool(client, {
+      tools: mcpTools,
+      providerTokens,
+      context: options?.context,
+      integrationIds: client.__oauthConfig?.integrations?.map((i) => i.id)
+    });
+    return [{
+      type: "function",
+      name: CODE_MODE_TOOL_NAME,
+      description: codeTool.description,
+      parameters: codeTool.parameters,
+      strict: options?.strict ?? null
+    }];
+  })() : mcpTools.map((mcpTool) => convertMCPToolToOpenAI(mcpTool, client, finalOptions));
   const triggerConfig = client.__triggerConfig;
   if (triggerConfig) {
     const triggerTools = createTriggerTools(triggerConfig, options?.context);
@@ -4449,6 +4981,19 @@ async function handleOpenAIToolCalls(client, toolCalls, options) {
   const toolOutputs = [];
   const triggerConfig = client.__triggerConfig;
   const triggerTools = triggerConfig ? createTriggerTools(triggerConfig, options?.context) : null;
+  let cachedCodeModeTool = null;
+  const getCodeModeTool = async () => {
+    if (cachedCodeModeTool)
+      return cachedCodeModeTool;
+    const mcpTools = await client.getEnabledToolsAsync();
+    cachedCodeModeTool = buildCodeModeTool(client, {
+      tools: mcpTools,
+      providerTokens: options?.providerTokens,
+      context: options?.context,
+      integrationIds: client.__oauthConfig?.integrations?.map((i) => i.id)
+    });
+    return cachedCodeModeTool;
+  };
   for (const output of toolCalls) {
     if (output.type === "function_call") {
       const toolCall = {
@@ -4459,7 +5004,10 @@ async function handleOpenAIToolCalls(client, toolCalls, options) {
       try {
         const args = JSON.parse(toolCall.arguments);
         let result;
-        if (triggerTools && triggerTools[toolCall.name]) {
+        if (toolCall.name === CODE_MODE_TOOL_NAME) {
+          const codeTool = await getCodeModeTool();
+          result = await codeTool.execute(args);
+        } else if (triggerTools && triggerTools[toolCall.name]) {
           result = await triggerTools[toolCall.name].execute(args);
         } else {
           result = await executeToolWithToken(client, toolCall.name, args, options);

package/dist/ai/vercel-ai.d.ts

@@ -22,6 +22,19 @@ export interface VercelAITool {
 export interface VercelAIToolsOptions extends AIToolsOptions {
     /** User context for multi-tenant token storage */
     context?: MCPContext;
+    /**
+     * How to expose MCP tools to the model.
+     *
+     * - `'code'` (default): Returns a single `execute_code` tool. The model writes
+     *   a TypeScript snippet that calls the typed `client.<integration>.<method>()`
+     *   API; the snippet runs in an isolated Vercel Sandbox and calls back into
+     *   `/api/integrate/mcp`. Chains multiple operations in one round-trip.
+     * - `'tools'`: Legacy behavior — returns one AI tool per MCP tool. Use this
+     *   if you can't run `@vercel/sandbox` or need the model to see every tool.
+     *
+     * @default 'code'
+     */
+    mode?: 'code' | 'tools';
 }
 /**
  * Get tools in a format compatible with Vercel AI SDK v5's tools parameter

package/dist/ai/vercel-ai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../src/ai/vercel-ai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAGpB;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IAC1D,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;CACtB;AA+BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,oBAAoB,gCAoC/B"}
+{"version":3,"file":"vercel-ai.d.ts","sourceRoot":"","sources":["../../../src/ai/vercel-ai.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,YAAY,CAAC;AAIpB;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IAC1D,kDAAkD;IAClD,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACzB;AA+BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,EACtB,OAAO,CAAC,EAAE,oBAAoB,gCAuD/B"}