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

package/dist/ai/google.js

@@ -4251,7 +4251,7 @@ function calculateHasMore(offset, returnedCount, total) {
 function createTriggerTools(config, context) {
   const { callbacks } = config;
   return {
-    create_trigger: {
+    trigger_create: {
       description: "Schedule a tool to run at a specific time or on a recurring schedule. Use this when the user wants to do something later.",
       inputSchema: exports_external.object({
         name: exports_external.string().optional().describe("Human-readable trigger name"),
@@ -4285,7 +4285,7 @@ function createTriggerTools(config, context) {
         return callbacks.create(trigger, context);
       }
     },
-    list_triggers: {
+    trigger_list: {
       description: "List all scheduled triggers with optional filtering by status or tool name",
       inputSchema: exports_external.object({
         status: exports_external.enum(["active", "paused", "completed", "failed"]).optional().describe("Filter by trigger status"),
@@ -4309,7 +4309,7 @@ function createTriggerTools(config, context) {
         };
       }
     },
-    get_trigger: {
+    trigger_get: {
       description: "Get details of a specific trigger by its ID",
       inputSchema: exports_external.object({
         triggerId: exports_external.string().describe("The trigger ID to retrieve")
@@ -4322,7 +4322,7 @@ function createTriggerTools(config, context) {
         return trigger;
       }
     },
-    update_trigger: {
+    trigger_update: {
       description: "Update a trigger's properties like name, description, arguments, or schedule",
       inputSchema: exports_external.object({
         triggerId: exports_external.string().describe("The trigger ID to update"),
@@ -4349,7 +4349,7 @@ function createTriggerTools(config, context) {
         return callbacks.update(triggerId, updatesWithTimestamp, context);
       }
     },
-    delete_trigger: {
+    trigger_delete: {
       description: "Delete a trigger permanently. This cannot be undone.",
       inputSchema: exports_external.object({
         triggerId: exports_external.string().describe("The trigger ID to delete")
@@ -4359,7 +4359,7 @@ function createTriggerTools(config, context) {
         return { success: true, message: `Trigger ${args.triggerId} deleted` };
       }
     },
-    pause_trigger: {
+    trigger_pause: {
       description: "Pause a trigger to temporarily stop it from executing. Can be resumed later.",
       inputSchema: exports_external.object({
         triggerId: exports_external.string().describe("The trigger ID to pause")
@@ -4379,7 +4379,7 @@ function createTriggerTools(config, context) {
         }, context);
       }
     },
-    resume_trigger: {
+    trigger_resume: {
       description: "Resume a paused trigger to start executing it again on schedule",
       inputSchema: exports_external.object({
         triggerId: exports_external.string().describe("The trigger ID to resume")
@@ -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
+  };
+}
+
 // google.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
 async function getGoogleType() {
@@ -4485,13 +5002,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);
@@ -4510,7 +5043,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);