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

package/dist/oauth.js

@@ -507,10 +507,17 @@ var init_errors = __esm(() => {
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
+function snakeToCamel(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
 function methodToToolName(methodName, integrationId) {
   const snakeCaseMethod = camelToSnake(methodName);
   return `${integrationId}_${snakeCaseMethod}`;
 }
+function toolNameToMethod(toolName) {
+  const withoutPrefix = toolName.replace(/^[^_]+_/, "");
+  return snakeToCamel(withoutPrefix);
+}
 
 // src/triggers/client.ts
 class TriggerClient {
@@ -8557,6 +8564,508 @@ var init_trigger_tools = __esm(() => {
   init_utils2();
 });
 
+// src/code-mode/type-generator.ts
+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";
+}
+var RESERVED_TS;
+var init_type_generator = __esm(() => {
+  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"
+  ]);
+});
+
+// src/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 };
+`;
+
+// src/code-mode/executor.ts
+var exports_executor = {};
+__export(exports_executor, {
+  executeSandboxCode: () => executeSandboxCode,
+  __setSandboxFactoryForTests: () => __setSandboxFactoryForTests
+});
+function __setSandboxFactoryForTests(factory) {
+  sandboxFactoryOverride = factory;
+}
+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`).");
+  }
+}
+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 {}
+    }
+  }
+}
+var sandboxFactoryOverride = null, RESULT_SENTINEL = "__INTEGRATE_RESULT__";
+var init_executor = () => {};
+
+// src/code-mode/tool-builder.ts
+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
+  };
+}
+var CODE_MODE_TOOL_NAME = "execute_code", DEFAULT_INSTRUCTIONS;
+var init_tool_builder = __esm(() => {
+  init_type_generator();
+  init_executor();
+  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(`
+`);
+});
+
 // src/ai/vercel-ai.ts
 function convertMCPToolToVercelAI(mcpTool, client, options) {
   return {
@@ -8581,8 +9090,25 @@ async function getVercelAITools(client, options) {
   await ensureClientConnected(client);
   const mcpTools = await client.getEnabledToolsAsync();
   const vercelTools = {};
-  for (const mcpTool of mcpTools) {
-    vercelTools[mcpTool.name] = convertMCPToolToVercelAI(mcpTool, client, finalOptions);
+  const mode = options?.mode ?? "code";
+  if (mode === "code") {
+    const codeTool = buildCodeModeTool(client, {
+      tools: mcpTools,
+      providerTokens,
+      context: options?.context,
+      integrationIds: client.__oauthConfig?.integrations?.map((i) => i.id) ?? client.integrations?.map?.((i) => i.id)
+    });
+    vercelTools[CODE_MODE_TOOL_NAME] = {
+      description: codeTool.description,
+      inputSchema: exports_external.object({
+        code: exports_external.string().describe(codeTool.parameters.properties.code.description)
+      }),
+      execute: async (args) => codeTool.execute(args)
+    };
+  } else {
+    for (const mcpTool of mcpTools) {
+      vercelTools[mcpTool.name] = convertMCPToolToVercelAI(mcpTool, client, finalOptions);
+    }
   }
   const triggerConfig = client.__triggerConfig;
   if (triggerConfig) {
@@ -8592,8 +9118,10 @@ async function getVercelAITools(client, options) {
   return vercelTools;
 }
 var init_vercel_ai = __esm(() => {
+  init_zod();
   init_utils();
   init_trigger_tools();
+  init_tool_builder();
 });
 
 // node_modules/zod-to-json-schema/dist/esm/Options.js
@@ -10021,7 +10549,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);
@@ -10046,6 +10589,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 = {
@@ -10056,7 +10612,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);
@@ -10097,6 +10656,7 @@ async function handleOpenAIResponse(client, response, options) {
 var init_openai = __esm(() => {
   init_utils();
   init_trigger_tools();
+  init_tool_builder();
   init_esm();
 });
 
@@ -10116,11 +10676,27 @@ async function handleAnthropicToolCalls(client, messageContent, options) {
   const toolResults = [];
   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;
+  };
   const toolUseBlocks = messageContent.filter((block) => block.type === "tool_use" && ("id" in block) && ("name" in block) && ("input" in block));
   for (const toolUse of toolUseBlocks) {
     try {
       let result;
-      if (triggerTools && triggerTools[toolUse.name]) {
+      if (toolUse.name === CODE_MODE_TOOL_NAME) {
+        const codeTool = await getCodeModeTool();
+        result = await codeTool.execute(toolUse.input);
+      } else if (triggerTools && triggerTools[toolUse.name]) {
         result = await triggerTools[toolUse.name].execute(toolUse.input);
       } else {
         result = await executeToolWithToken(client, toolUse.name, toolUse.input, options);
@@ -10153,7 +10729,24 @@ async function getAnthropicTools(client, options) {
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   await ensureClientConnected(client);
   const mcpTools = await client.getEnabledToolsAsync();
-  const anthropicTools = mcpTools.map((mcpTool) => convertMCPToolToAnthropic(mcpTool, client, finalOptions));
+  const mode = options?.mode ?? "code";
+  const anthropicTools = mode === "code" ? (() => {
+    const codeTool = buildCodeModeTool(client, {
+      tools: mcpTools,
+      providerTokens,
+      context: options?.context,
+      integrationIds: client.__oauthConfig?.integrations?.map((i) => i.id)
+    });
+    return [{
+      name: CODE_MODE_TOOL_NAME,
+      description: codeTool.description,
+      input_schema: {
+        type: "object",
+        properties: codeTool.parameters.properties,
+        required: [...codeTool.parameters.required]
+      }
+    }];
+  })() : mcpTools.map((mcpTool) => convertMCPToolToAnthropic(mcpTool, client, finalOptions));
   const triggerConfig = client.__triggerConfig;
   if (triggerConfig) {
     const triggerTools = createTriggerTools(triggerConfig, options?.context);
@@ -10198,6 +10791,7 @@ async function handleAnthropicMessage(client, message, options) {
 var init_anthropic = __esm(() => {
   init_utils();
   init_trigger_tools();
+  init_tool_builder();
   init_esm();
 });
 
@@ -10283,13 +10877,29 @@ async function executeGoogleFunctionCalls(client, functionCalls, options) {
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   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: finalOptions?.providerTokens,
+      context: options?.context,
+      integrationIds: client.__oauthConfig?.integrations?.map((i) => i.id)
+    });
+    return cachedCodeModeTool;
+  };
   const results = await Promise.all(functionCalls.map(async (call) => {
     if (!call?.name) {
       throw new Error("Function call must have a name");
     }
     const args = call.args || {};
     let result;
-    if (triggerTools && triggerTools[call.name]) {
+    if (call.name === CODE_MODE_TOOL_NAME) {
+      const codeTool = await getCodeModeTool();
+      result = await codeTool.execute(args);
+    } else if (triggerTools && triggerTools[call.name]) {
       result = await triggerTools[call.name].execute(args);
     } else {
       result = await executeToolWithToken(client, call.name, args, finalOptions);
@@ -10308,7 +10918,33 @@ async function getGoogleTools(client, options) {
   const finalOptions = providerTokens ? { ...options, providerTokens } : options;
   await ensureClientConnected(client);
   const mcpTools = await client.getEnabledToolsAsync();
-  const googleTools = await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, finalOptions)));
+  const mode = options?.mode ?? "code";
+  let googleTools;
+  if (mode === "code") {
+    const TypeEnum = await getGoogleType();
+    const codeTool = buildCodeModeTool(client, {
+      tools: mcpTools,
+      providerTokens,
+      context: options?.context,
+      integrationIds: client.__oauthConfig?.integrations?.map((i) => i.id)
+    });
+    googleTools = [{
+      name: CODE_MODE_TOOL_NAME,
+      description: codeTool.description,
+      parameters: {
+        type: TypeEnum.OBJECT,
+        properties: {
+          code: {
+            type: TypeEnum.STRING,
+            description: codeTool.parameters.properties.code.description
+          }
+        },
+        required: ["code"]
+      }
+    }];
+  } else {
+    googleTools = await Promise.all(mcpTools.map((mcpTool) => convertMCPToolToGoogle(mcpTool, client, finalOptions)));
+  }
   const triggerConfig = client.__triggerConfig;
   if (triggerConfig) {
     const triggerTools = createTriggerTools(triggerConfig, options?.context);
@@ -10386,6 +11022,7 @@ function convertJsonSchemaToGoogleSchema(jsonSchema, TypeEnum) {
 var init_google = __esm(() => {
   init_utils();
   init_trigger_tools();
+  init_tool_builder();
   init_esm();
 });
 
@@ -10451,8 +11088,8 @@ var init_webhooks = __esm(() => {
 var MAX_TRIGGER_STEPS = 20, WEBHOOK_DELIVERY_TIMEOUT_MS = 1e4;
 
 // src/triggers/executor.ts
-var exports_executor = {};
-__export(exports_executor, {
+var exports_executor2 = {};
+__export(exports_executor2, {
   executeTrigger: () => executeTrigger
 });
 async function executeTrigger(trigger, config, context) {
@@ -10599,7 +11236,7 @@ async function executeTrigger(trigger, config, context) {
   return { success: false, steps, error: limitError };
 }
 var logger31;
-var init_executor = __esm(() => {
+var init_executor2 = __esm(() => {
   init_logger();
   init_utils2();
   init_webhooks();
@@ -10744,7 +11381,8 @@ function createMCPServer(config) {
     integrations: updatedIntegrations,
     getSessionContext: config.getSessionContext,
     setProviderToken: config.setProviderToken,
-    removeProviderToken: config.removeProviderToken
+    removeProviderToken: config.removeProviderToken,
+    codeMode: config.codeMode
   };
   client.__triggerConfig = config.triggers ? {
     callbacks: config.triggers,
@@ -10814,8 +11452,21 @@ function createMCPServer(config) {
     if (action === "mcp" && method === "POST") {
       try {
         const body = await webRequest.json();
-        const authHeader = webRequest.headers.get("authorization");
+        let authHeader = webRequest.headers.get("authorization");
         const integrationsHeader = webRequest.headers.get("x-integrations");
+        if (!authHeader) {
+          const tokensHeader = webRequest.headers.get("x-integrate-tokens");
+          const toolName = typeof body?.name === "string" ? body.name : "";
+          if (tokensHeader && toolName) {
+            try {
+              const tokens = JSON.parse(tokensHeader);
+              const provider = toolName.split("_")[0];
+              if (provider && tokens[provider]) {
+                authHeader = `Bearer ${tokens[provider]}`;
+              }
+            } catch {}
+          }
+        }
         const { OAuthHandler: OAuthHandler2 } = await Promise.resolve().then(() => (init_base_handler(), exports_base_handler));
         const oauthHandler = new OAuthHandler2({
           providers,
@@ -10836,6 +11487,53 @@ function createMCPServer(config) {
         return Response.json({ error: error.message || "Failed to execute tool call" }, { status: error.statusCode || 500 });
       }
     }
+    if (action === "code" && method === "POST") {
+      try {
+        const body = await webRequest.json();
+        if (typeof body?.code !== "string" || body.code.length === 0) {
+          return Response.json({ error: "`code` is required and must be a non-empty string." }, { status: 400 });
+        }
+        const { executeSandboxCode: executeSandboxCode2 } = await Promise.resolve().then(() => (init_executor(), exports_executor));
+        const codeModeConfig = config.codeMode ?? {};
+        const publicUrl = codeModeConfig.publicUrl ?? getEnv("INTEGRATE_PUBLIC_URL");
+        if (!publicUrl) {
+          return Response.json({
+            error: "Code Mode requires `codeMode.publicUrl` in createMCPServer config (or the INTEGRATE_PUBLIC_URL env var). Set it to the public origin where /api/integrate/mcp is reachable."
+          }, { status: 500 });
+        }
+        let contextOverride = body.context;
+        if (!contextOverride && config.getSessionContext) {
+          try {
+            contextOverride = await config.getSessionContext(webRequest);
+          } catch {}
+        }
+        let providerTokens = body.providerTokens;
+        if (!providerTokens) {
+          const headerTokens = webRequest.headers.get("x-integrate-tokens");
+          if (headerTokens) {
+            try {
+              providerTokens = JSON.parse(headerTokens);
+            } catch {}
+          }
+        }
+        const integrationIds = updatedIntegrations.map((i) => i.id);
+        const result = await executeSandboxCode2({
+          code: body.code,
+          mcpUrl: publicUrl.replace(/\/$/, "") + "/api/integrate/mcp",
+          providerTokens,
+          context: contextOverride,
+          integrationsHeader: integrationIds.join(","),
+          runtime: codeModeConfig.runtime,
+          timeoutMs: codeModeConfig.timeoutMs,
+          vcpus: codeModeConfig.vcpus,
+          networkPolicy: codeModeConfig.networkPolicy
+        });
+        return Response.json(result, { status: result.success ? 200 : 500 });
+      } catch (error) {
+        logger32.error("[Code Mode] Error:", error);
+        return Response.json({ error: error?.message || "Failed to execute code" }, { status: 500 });
+      }
+    }
     if (action === "integrations" && method === "GET") {
       const integrations = updatedIntegrations.map((integration) => ({
         id: integration.id,
@@ -10871,7 +11569,7 @@ function createMCPServer(config) {
           return Response.json({ error: "Trigger has no provider configured" }, { status: 400 });
         }
         const triggerContext = trigger.userId ? { userId: trigger.userId } : undefined;
-        const { executeTrigger: executeTrigger2 } = await Promise.resolve().then(() => (init_executor(), exports_executor));
+        const { executeTrigger: executeTrigger2 } = await Promise.resolve().then(() => (init_executor2(), exports_executor2));
         const { OAuthHandler: OAuthHandler2 } = await Promise.resolve().then(() => (init_base_handler(), exports_base_handler));
         const oauthHandler = new OAuthHandler2({
           providers,
@@ -11034,7 +11732,7 @@ function createMCPServer(config) {
             if (!trigger.provider) {
               return Response.json({ error: "Trigger has no provider configured" }, { status: 400 });
             }
-            const { executeTrigger: executeTrigger2 } = await Promise.resolve().then(() => (init_executor(), exports_executor));
+            const { executeTrigger: executeTrigger2 } = await Promise.resolve().then(() => (init_executor2(), exports_executor2));
             const { OAuthHandler: OAuthHandler2 } = await Promise.resolve().then(() => (init_base_handler(), exports_base_handler));
             const oauthHandler = new OAuthHandler2({
               providers,