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

package/dist/code-mode/executor.js

@@ -0,0 +1,207 @@
+// 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 };
+`;
+
+// executor.ts
+var sandboxFactoryOverride = null;
+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`).");
+  }
+}
+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 {}
+    }
+  }
+}
+export {
+  executeSandboxCode,
+  __setSandboxFactoryForTests
+};

package/dist/code-mode/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Code Mode public surface
+ *
+ * Re-exports the pieces needed to build the `execute_code` tool that AI
+ * helpers hand to the LLM and the server-side executor that runs that code
+ * in a Vercel Sandbox.
+ */
+export { generateCodeModeTypes, type GeneratedTypes, } from "./type-generator.js";
+export { executeSandboxCode, __setSandboxFactoryForTests, type ExecuteSandboxCodeOptions, type ExecuteSandboxCodeResult, } from "./executor.js";
+export { RUNTIME_STUB_SOURCE } from "./runtime-stub.js";
+export { buildCodeModeTool, CODE_MODE_TOOL_NAME, type CodeModeToolOptions, type CodeModeToolDefinition, } from "./tool-builder.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/code-mode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/code-mode/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,qBAAqB,EACrB,KAAK,cAAc,GACpB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,kBAAkB,EAClB,2BAA2B,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,GAC9B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,GAC5B,MAAM,mBAAmB,CAAC"}