lua-cli 3.45.0 → 3.46.0

package/dist/workflow-builder.js

@@ -84,8 +84,8 @@ function workflowJobTargetTemplatePath(binding) {
 __name(workflowJobTargetTemplatePath, "workflowJobTargetTemplatePath");
 __name2(workflowJobTargetTemplatePath, "workflowJobTargetTemplatePath");
 function isWorkflowJobTargetTemplate(target) {
-  const agentId = target?.agentId;
-  return !!agentId && typeof agentId === "object";
+  const agentId2 = target?.agentId;
+  return !!agentId2 && typeof agentId2 === "object";
 }
 __name(isWorkflowJobTargetTemplate, "isWorkflowJobTargetTemplate");
 __name2(isWorkflowJobTargetTemplate, "isWorkflowJobTargetTemplate");
@@ -107,12 +107,12 @@ function workflowJobTargetProblem(target, plugins, luaApi) {
   if (target === void 0) return null;
   if (!target || typeof target !== "object" || Array.isArray(target)) return "target must be { agentId }";
   const keys = Object.keys(target);
-  const agentId = target.agentId;
+  const agentId2 = target.agentId;
   if (keys.length !== 1 || !("agentId" in target)) return "target must be exactly { agentId }";
-  if (typeof agentId === "string") {
-    if (!agentId.trim() || agentId.length > 256) return "target must be exactly { agentId: <non-empty string> }";
-    if (agentId.includes("${")) return "a run-input target is written template('${initData.<path>}'), never a string with ${\u2026}";
-  } else if (workflowJobTargetTemplatePath(agentId) === null) {
+  if (typeof agentId2 === "string") {
+    if (!agentId2.trim() || agentId2.length > 256) return "target must be exactly { agentId: <non-empty string> }";
+    if (agentId2.includes("${")) return "a run-input target is written template('${initData.<path>}'), never a string with ${\u2026}";
+  } else if (workflowJobTargetTemplatePath(agentId2) === null) {
     return "target.agentId must be a static id or template('${initData.<path>}') \u2014 exactly one initData placeholder, no default";
   }
   const hasPlugins = Array.isArray(plugins) && plugins.length > 0;
@@ -140,25 +140,25 @@ function readInitDataPath(root, path) {
 __name(readInitDataPath, "readInitDataPath");
 __name2(readInitDataPath, "readInitDataPath");
 function renderWorkflowJobTarget(target, initData) {
-  const agentId = target?.agentId;
-  if (target === void 0 || target === null || agentId === void 0) return {
+  const agentId2 = target?.agentId;
+  if (target === void 0 || target === null || agentId2 === void 0) return {
     ok: true,
     agentId: void 0,
     templated: false
   };
-  if (typeof agentId === "string") {
-    if (!agentId.trim() || agentId.includes("${")) return {
+  if (typeof agentId2 === "string") {
+    if (!agentId2.trim() || agentId2.includes("${")) return {
       ok: false,
       reason: "invalid",
       message: "target.agentId is invalid"
     };
     return {
       ok: true,
-      agentId,
+      agentId: agentId2,
       templated: false
     };
   }
-  const path = workflowJobTargetTemplatePath(agentId);
+  const path = workflowJobTargetTemplatePath(agentId2);
   if (path === null) return {
     ok: false,
     reason: "invalid",
@@ -196,6 +196,7 @@ import { z } from "zod";
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
 import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var __defProp3 = Object.defineProperty;
 var __name3 = /* @__PURE__ */ __name((target, value3) => __defProp3(target, "name", { value: value3, configurable: true }), "__name");
 var PLUMBING_THREAD_CHANNELS = [
@@ -433,8 +434,8 @@ function isPlatformInvocationCaller(v) {
 }
 __name(isPlatformInvocationCaller, "isPlatformInvocationCaller");
 __name3(isPlatformInvocationCaller, "isPlatformInvocationCaller");
-function supervisionSubjectId(agentId) {
-  return `agent:${agentId}`;
+function supervisionSubjectId(agentId2) {
+  return `agent:${agentId2}`;
 }
 __name(supervisionSubjectId, "supervisionSubjectId");
 __name3(supervisionSubjectId, "supervisionSubjectId");
@@ -561,7 +562,14 @@ var SUPERVISION_OPS = {
   * that was ACTIVE before, is OLDER than the active one and was active within the last 7 days. CAS on the active
   * version; only from a workflow step the watchdog grant names. Held only by a watchdog grant.
   */
-  "versions.rollback": "rollback"
+  "versions.rollback": "rollback",
+  // [JR]
+  /**
+  * JR (BAC-2011) — `Agents.jobs(id).register({ versionId, jobId })`: register a job that is pinned in a STAGED version of
+  * the target (`snapshot.jobs[]`) so the promote activates and schedules it. Mongo-only marker write; EventBridge stays
+  * on the post-promote reconcile. Release-class: needs `register-job` AND `release` on the grant, from a signed step.
+  */
+  "jobs.register": "register-job"
 };
 function isSupervisionOp(op) {
   return typeof op === "string" && Object.prototype.hasOwnProperty.call(SUPERVISION_OPS, op);
@@ -754,6 +762,12 @@ var SUPERVISION_OPS_WAVE2 = {
     gate: "rollback",
     targeted: true,
     item: "WD"
+  },
+  /** JR (BAC-2011) — `Agents.jobs(id).register({ versionId, jobId })`: a job pinned in a STAGED version (`register-job`). */
+  "jobs.register": {
+    gate: "register-job",
+    targeted: true,
+    item: "JR"
   }
 };
 var SUPERVISION_WATCHDOG_OPS = {
@@ -1686,9 +1700,9 @@ function isAgentConnectionMountMode(value3) {
 }
 __name(isAgentConnectionMountMode, "isAgentConnectionMountMode");
 __name3(isAgentConnectionMountMode, "isAgentConnectionMountMode");
-function agentConnectionBindingFor(bindings, agentId) {
-  if (!Array.isArray(bindings) || !agentId) return void 0;
-  return bindings.find((entry) => !!entry && typeof entry === "object" && entry.agentId === agentId);
+function agentConnectionBindingFor(bindings, agentId2) {
+  if (!Array.isArray(bindings) || !agentId2) return void 0;
+  return bindings.find((entry) => !!entry && typeof entry === "object" && entry.agentId === agentId2);
 }
 __name(agentConnectionBindingFor, "agentConnectionBindingFor");
 __name3(agentConnectionBindingFor, "agentConnectionBindingFor");
@@ -2260,8 +2274,8 @@ function describeConnectionRequest(input) {
 }
 __name(describeConnectionRequest, "describeConnectionRequest");
 __name3(describeConnectionRequest, "describeConnectionRequest");
-function operationDailyCapKey(agentId, connectionId, currency, utcDay) {
-  return `opcap:${agentId}:${connectionId}:${currency.toUpperCase()}:${utcDay}`;
+function operationDailyCapKey(agentId2, connectionId, currency, utcDay) {
+  return `opcap:${agentId2}:${connectionId}:${currency.toUpperCase()}:${utcDay}`;
 }
 __name(operationDailyCapKey, "operationDailyCapKey");
 __name3(operationDailyCapKey, "operationDailyCapKey");
@@ -2318,7 +2332,7 @@ function parseCapAmount(value3) {
 }
 __name(parseCapAmount, "parseCapAmount");
 __name3(parseCapAmount, "parseCapAmount");
-function parseAgentConnectionOperationLimits(agentId, value3) {
+function parseAgentConnectionOperationLimits(agentId2, value3) {
   if (!isPlainObject(value3)) return {
     ok: false,
     error: "limits must be an object"
@@ -2331,7 +2345,7 @@ function parseAgentConnectionOperationLimits(agentId, value3) {
     };
   }
   const limits = {
-    agentId
+    agentId: agentId2
   };
   if (value3.caps !== void 0 && value3.caps !== null) {
     const caps = value3.caps;
@@ -2419,17 +2433,17 @@ function parseAgentConnectionOperationLimits(agentId, value3) {
 }
 __name(parseAgentConnectionOperationLimits, "parseAgentConnectionOperationLimits");
 __name3(parseAgentConnectionOperationLimits, "parseAgentConnectionOperationLimits");
-function findAgentConnectionOperationLimits(stored, agentId) {
-  if (!agentId || stored === void 0 || stored === null) return void 0;
+function findAgentConnectionOperationLimits(stored, agentId2) {
+  if (!agentId2 || stored === void 0 || stored === null) return void 0;
   if (!Array.isArray(stored)) return {
-    agentId,
+    agentId: agentId2,
     unreadable: true
   };
-  const entry = stored.find((row) => isPlainObject(row) && row.agentId === agentId);
+  const entry = stored.find((row) => isPlainObject(row) && row.agentId === agentId2);
   if (!entry) return void 0;
-  const parsed = parseAgentConnectionOperationLimits(agentId, entry);
+  const parsed = parseAgentConnectionOperationLimits(agentId2, entry);
   return parsed.ok ? parsed.limits : {
-    agentId,
+    agentId: agentId2,
     unreadable: true
   };
 }
@@ -3206,9 +3220,9 @@ function evalCaseThreadId(runId, caseId) {
 }
 __name(evalCaseThreadId, "evalCaseThreadId");
 __name3(evalCaseThreadId, "evalCaseThreadId");
-function evalMonthlyCapKey(agentId, at = /* @__PURE__ */ new Date()) {
+function evalMonthlyCapKey(agentId2, at = /* @__PURE__ */ new Date()) {
   const yyyymm = `${at.getUTCFullYear()}${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
-  return `evalcap:${agentId}:${yyyymm}`;
+  return `evalcap:${agentId2}:${yyyymm}`;
 }
 __name(evalMonthlyCapKey, "evalMonthlyCapKey");
 __name3(evalMonthlyCapKey, "evalMonthlyCapKey");
@@ -3313,8 +3327,8 @@ function normalizedHandoverName(name) {
 }
 __name(normalizedHandoverName, "normalizedHandoverName");
 __name3(normalizedHandoverName, "normalizedHandoverName");
-function handoverAgentIdSuffix(agentId) {
-  return agentId.slice(-6);
+function handoverAgentIdSuffix(agentId2) {
+  return agentId2.slice(-6);
 }
 __name(handoverAgentIdSuffix, "handoverAgentIdSuffix");
 __name3(handoverAgentIdSuffix, "handoverAgentIdSuffix");
@@ -3761,11 +3775,11 @@ function parseThreadFollowUpInput(input) {
 }
 __name(parseThreadFollowUpInput, "parseThreadFollowUpInput");
 __name3(parseThreadFollowUpInput, "parseThreadFollowUpInput");
-function threadFollowUpRateKeys(agentId, threadId, nowMs) {
+function threadFollowUpRateKeys(agentId2, threadId, nowMs) {
   const hour = Math.floor(nowMs / 36e5);
   return {
-    perThread: `thread-followup:${agentId}:${threadId}:${hour}`,
-    perAgent: `thread-followup:${agentId}:${hour}`
+    perThread: `thread-followup:${agentId2}:${threadId}:${hour}`,
+    perAgent: `thread-followup:${agentId2}:${hour}`
   };
 }
 __name(threadFollowUpRateKeys, "threadFollowUpRateKeys");
@@ -8587,8 +8601,8 @@ function scheduleHealthView(health, state3) {
 }
 __name(scheduleHealthView, "scheduleHealthView");
 __name3(scheduleHealthView, "scheduleHealthView");
-function scheduleHealthSourceId(agentId, jobId) {
-  return `schedule-health:${agentId}:${jobId}`;
+function scheduleHealthSourceId(agentId2, jobId) {
+  return `schedule-health:${agentId2}:${jobId}`;
 }
 __name(scheduleHealthSourceId, "scheduleHealthSourceId");
 __name3(scheduleHealthSourceId, "scheduleHealthSourceId");
@@ -9947,7 +9961,7 @@ function evidenceDays(from, to) {
 __name(evidenceDays, "evidenceDays");
 __name3(evidenceDays, "evidenceDays");
 function summarizeEvidence(input) {
-  const { agentId, from, to } = input;
+  const { agentId: agentId2, from, to } = input;
   const windowDays = evidenceDays(from, to);
   const readable = /* @__PURE__ */ __name3((s) => s === "ok" || s === "empty", "readable");
   const covered = /* @__PURE__ */ __name3((d) => readable(d.sources?.messages) && readable(d.sources?.analyses), "covered");
@@ -10021,7 +10035,7 @@ function summarizeEvidence(input) {
   const short = wordRows.reduce((a, h) => a + h.short, 0);
   const long = wordRows.reduce((a, h) => a + h.long, 0);
   return {
-    agentId,
+    agentId: agentId2,
     window: {
       from,
       to,
@@ -10779,7 +10793,7 @@ function classifyConnectionOperation(op) {
 __name(classifyConnectionOperation, "classifyConnectionOperation");
 __name3(classifyConnectionOperation, "classifyConnectionOperation");
 function connectionSendPolicyIsActive(policy) {
-  return Boolean(policy) && (policy.allowSend === false || Array.isArray(policy.recipientAllowlist));
+  return !!policy && (policy.allowSend === false || Array.isArray(policy.recipientAllowlist));
 }
 __name(connectionSendPolicyIsActive, "connectionSendPolicyIsActive");
 __name3(connectionSendPolicyIsActive, "connectionSendPolicyIsActive");
@@ -10815,8 +10829,9 @@ function evaluateConnectionSendPolicy(policy, op) {
       classification
     };
   }
-  if (Array.isArray(policy.recipientAllowlist)) {
-    const denied = classification.recipients.filter((email) => !allowlistAdmits(policy.recipientAllowlist, email));
+  const allowlist = policy.recipientAllowlist;
+  if (Array.isArray(allowlist)) {
+    const denied = classification.recipients.filter((email) => !allowlistAdmits(allowlist, email));
     if (denied.length > 0 || classification.recipientsUnknown) {
       return {
         allowed: false,
@@ -10870,10 +10885,605 @@ function isPaymentRequiredChatErrorEnvelope(data) {
 }
 __name(isPaymentRequiredChatErrorEnvelope, "isPaymentRequiredChatErrorEnvelope");
 __name3(isPaymentRequiredChatErrorEnvelope, "isPaymentRequiredChatErrorEnvelope");
+var CUSTOM_MCP_CONNECTION_ID_PREFIX = "mcp_";
+var CUSTOM_MCP_SOURCE = "custom";
+var CUSTOM_MCP_TRANSPORT = "streamable-http";
+var CUSTOM_MCP_CONNECTION_ID_PATTERN = /^mcp_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function isCustomMcpConnectionId(id2) {
+  return typeof id2 === "string" && id2.startsWith(CUSTOM_MCP_CONNECTION_ID_PREFIX);
+}
+__name(isCustomMcpConnectionId, "isCustomMcpConnectionId");
+__name3(isCustomMcpConnectionId, "isCustomMcpConnectionId");
+var customMcpConnectionIdSchema = z5.string().regex(CUSTOM_MCP_CONNECTION_ID_PATTERN);
+var CONNECTION_BACKED_MCP_SOURCES = [
+  "unifiedto",
+  CUSTOM_MCP_SOURCE
+];
+function isConnectionBackedMcpSource(source) {
+  return typeof source === "string" && CONNECTION_BACKED_MCP_SOURCES.includes(source);
+}
+__name(isConnectionBackedMcpSource, "isConnectionBackedMcpSource");
+__name3(isConnectionBackedMcpSource, "isConnectionBackedMcpSource");
+var CUSTOM_MCP_REFERENCE_ID_PATTERN = /^mcpx_[0-9a-f]{12}$/;
+var customMcpReferenceIdSchema = z5.string().regex(CUSTOM_MCP_REFERENCE_ID_PATTERN);
+function newCustomMcpReferenceId() {
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(6));
+  return `mcpx_${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+__name(newCustomMcpReferenceId, "newCustomMcpReferenceId");
+__name3(newCustomMcpReferenceId, "newCustomMcpReferenceId");
+var CUSTOM_MCP_AUTH_KINDS = [
+  "none",
+  "headers",
+  "oauth"
+];
+var customMcpAuthKindSchema = z5.enum(CUSTOM_MCP_AUTH_KINDS);
+var CUSTOM_MCP_OAUTH_REGISTRATIONS = [
+  "cimd",
+  "dcr",
+  "manual"
+];
+var customMcpOAuthRegistrationSchema = z5.enum(CUSTOM_MCP_OAUTH_REGISTRATIONS);
+var CUSTOM_MCP_HEALTH_STATES = [
+  "ok",
+  "failing",
+  "needs_sign_in",
+  "auth_rejected"
+];
+var customMcpHealthStateSchema = z5.enum(CUSTOM_MCP_HEALTH_STATES);
+var CUSTOM_MCP_FAILURE_STEPS = [
+  "url",
+  "reach",
+  "auth_challenge",
+  "resource_metadata",
+  "authorization_server_metadata",
+  "pkce",
+  "client_registration",
+  "authorize",
+  "token_exchange",
+  "list_tools"
+];
+var customMcpFailureStepSchema = z5.enum(CUSTOM_MCP_FAILURE_STEPS);
+var CUSTOM_MCP_CONNECT_STEPS = [
+  "url",
+  "reach",
+  "auth_challenge",
+  "list_tools"
+];
+var customMcpConnectStepSchema = z5.enum(CUSTOM_MCP_CONNECT_STEPS);
+var customMcpFailureCodeSchema = z5.string().regex(/^[a-z0-9_]{1,64}$/);
+var WORKFLOW_KEY_MAX_LENGTH = 64;
+function customMcpWorkflowKey(displayName) {
+  const slug = displayName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!slug) return `s-${fnv1a32(displayName.trim())}`;
+  return (/^[a-z]/.test(slug) ? slug : `s-${slug}`).slice(0, WORKFLOW_KEY_MAX_LENGTH);
+}
+__name(customMcpWorkflowKey, "customMcpWorkflowKey");
+__name3(customMcpWorkflowKey, "customMcpWorkflowKey");
+function fnv1a32(value3) {
+  let hash = 2166136261;
+  for (const char of value3) {
+    hash ^= char.codePointAt(0) ?? 0;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+__name(fnv1a32, "fnv1a32");
+__name3(fnv1a32, "fnv1a32");
+var CUSTOM_MCP_URL_MAX_LENGTH = 2048;
+var CUSTOM_MCP_DISPLAY_NAME_MAX_LENGTH = 120;
+var CUSTOM_MCP_MAX_HEADERS = 20;
+var CUSTOM_MCP_HEADER_NAME_MAX_LENGTH = 128;
+var CUSTOM_MCP_HEADER_VALUE_MAX_LENGTH = 8192;
+var CUSTOM_MCP_MAX_TOOLS = 500;
+var CUSTOM_MCP_TOOL_NAME_MAX_LENGTH = 256;
+var CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH = 1024;
+var CUSTOM_MCP_MIN_TIMEOUT_MS = 1e3;
+var CUSTOM_MCP_MAX_TIMEOUT_MS = 12e4;
+var CUSTOM_MCP_OAUTH_PENDING_TTL_MS = 15 * 6e4;
+var isoDateTime = z5.string().datetime({
+  offset: true
+});
+var agentId = z5.string().min(1).max(128);
+var nonNegativeInt = z5.number().int().min(0);
+var customMcpUrlInputSchema = z5.string().trim().min(1).max(CUSTOM_MCP_URL_MAX_LENGTH);
+var customMcpDisplayNameSchema = z5.string().trim().min(1).max(CUSTOM_MCP_DISPLAY_NAME_MAX_LENGTH);
+var customMcpTimeoutSchema = z5.number().int().min(CUSTOM_MCP_MIN_TIMEOUT_MS).max(CUSTOM_MCP_MAX_TIMEOUT_MS);
+var CUSTOM_MCP_RESERVED_HEADER_NAMES = [
+  "accept",
+  "connection",
+  "content-length",
+  "content-type",
+  "host",
+  "keep-alive",
+  "last-event-id",
+  "mcp-protocol-version",
+  "mcp-session-id",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+var HEADER_NAME = /^[A-Za-z][A-Za-z0-9!#$%&'*+.^_`|~-]*$/;
+var HEADER_VALUE_FORBIDDEN = /[\u0000-\u0008\u000a-\u001f\u007f]/;
+var customMcpHeaderNameSchema = z5.string().min(1).max(CUSTOM_MCP_HEADER_NAME_MAX_LENGTH).regex(HEADER_NAME, "Not a valid HTTP header name").refine((name) => !CUSTOM_MCP_RESERVED_HEADER_NAMES.includes(name.toLowerCase()), "This header is set by Lua");
+var headerValue = z5.string().min(1).max(CUSTOM_MCP_HEADER_VALUE_MAX_LENGTH).refine((value3) => !HEADER_VALUE_FORBIDDEN.test(value3), "Header values cannot contain line breaks");
+function addCaseDuplicateIssues(names, ctx, path) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const lower2 = name.toLowerCase();
+    if (seen.has(lower2)) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path,
+        message: `Header "${name}" is listed twice`
+      });
+    }
+    seen.add(lower2);
+  }
+}
+__name(addCaseDuplicateIssues, "addCaseDuplicateIssues");
+__name3(addCaseDuplicateIssues, "addCaseDuplicateIssues");
+var customMcpHeadersSchema = z5.record(customMcpHeaderNameSchema, headerValue).superRefine((headers, ctx) => {
+  const names = Object.keys(headers);
+  if (names.length > CUSTOM_MCP_MAX_HEADERS) {
+    ctx.addIssue({
+      code: z5.ZodIssueCode.custom,
+      message: `At most ${CUSTOM_MCP_MAX_HEADERS} headers`
+    });
+  }
+  addCaseDuplicateIssues(names, ctx, []);
+});
+var customMcpHeadersPatchSchema = z5.object({
+  set: customMcpHeadersSchema.optional(),
+  remove: z5.array(customMcpHeaderNameSchema).max(CUSTOM_MCP_MAX_HEADERS).optional()
+}).strict().superRefine((patch, ctx) => {
+  const set = Object.keys(patch.set ?? {});
+  const remove = patch.remove ?? [];
+  if (!set.length && !remove.length) {
+    ctx.addIssue({
+      code: z5.ZodIssueCode.custom,
+      message: "Nothing to change"
+    });
+  }
+  addCaseDuplicateIssues(remove, ctx, [
+    "remove"
+  ]);
+  const setLower = new Set(set.map((name) => name.toLowerCase()));
+  for (const name of remove) {
+    if (setLower.has(name.toLowerCase())) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: [
+          "remove"
+        ],
+        message: `Header "${name}" is both set and removed`
+      });
+    }
+  }
+});
+var customMcpToolNameSchema = z5.string().min(1).max(CUSTOM_MCP_TOOL_NAME_MAX_LENGTH);
+var customMcpToolSchema = z5.object({
+  name: customMcpToolNameSchema,
+  title: z5.string().max(CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH).optional(),
+  description: z5.string().max(CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH).optional()
+});
+var customMcpServerInfoSchema = z5.object({
+  name: z5.string().max(CUSTOM_MCP_TOOL_NAME_MAX_LENGTH),
+  version: z5.string().max(128).optional(),
+  title: z5.string().max(CUSTOM_MCP_TOOL_NAME_MAX_LENGTH).optional()
+});
+function toCustomMcpToolSnapshot(tools) {
+  const snapshot = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    if (snapshot.length >= CUSTOM_MCP_MAX_TOOLS) break;
+    const name = tool.name;
+    if (typeof name !== "string" || !name || name.length > CUSTOM_MCP_TOOL_NAME_MAX_LENGTH || seen.has(name)) continue;
+    seen.add(name);
+    snapshot.push({
+      name,
+      ...typeof tool.title === "string" && tool.title ? {
+        title: tool.title.slice(0, CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH)
+      } : {},
+      ...typeof tool.description === "string" && tool.description ? {
+        description: tool.description.slice(0, CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH)
+      } : {}
+    });
+  }
+  return snapshot;
+}
+__name(toCustomMcpToolSnapshot, "toCustomMcpToolSnapshot");
+__name3(toCustomMcpToolSnapshot, "toCustomMcpToolSnapshot");
+var customMcpToolSelectionSchema = z5.object({
+  allowAll: z5.boolean(),
+  enabled: z5.array(customMcpToolNameSchema).max(CUSTOM_MCP_MAX_TOOLS)
+}).strict().refine((selection) => new Set(selection.enabled).size === selection.enabled.length, {
+  path: [
+    "enabled"
+  ],
+  message: "Tool names must be unique"
+});
+function customMcpRuntimeToolFilter(selection) {
+  return selection.allowAll ? void 0 : {
+    allow: [
+      ...selection.enabled
+    ]
+  };
+}
+__name(customMcpRuntimeToolFilter, "customMcpRuntimeToolFilter");
+__name3(customMcpRuntimeToolFilter, "customMcpRuntimeToolFilter");
+var customMcpToolsResponseSchema = z5.object({
+  allowAll: z5.boolean(),
+  tools: z5.array(customMcpToolSchema.extend({
+    enabled: z5.boolean()
+  })),
+  serverInfo: customMcpServerInfoSchema.optional(),
+  refreshedAt: isoDateTime.optional()
+});
+var customMcpFailureSchema = z5.object({
+  step: customMcpFailureStepSchema,
+  code: customMcpFailureCodeSchema,
+  /** Plain words for the person connecting. */
+  message: z5.string().max(500),
+  httpStatus: z5.number().int().min(100).max(599).optional(),
+  referenceId: customMcpReferenceIdSchema
+});
+var customMcpHealthSchema = z5.object({
+  state: customMcpHealthStateSchema,
+  checkedAt: isoDateTime.optional(),
+  lastOkAt: isoDateTime.optional(),
+  lastFailureAt: isoDateTime.optional(),
+  consecutiveFailures: nonNegativeInt,
+  lastFailure: customMcpFailureSchema.omit({
+    message: true
+  }).optional()
+});
+var customMcpErrorBodySchema = z5.object({
+  code: z5.string(),
+  message: z5.string(),
+  failure: customMcpFailureSchema.optional(),
+  callbackUrl: z5.string().url().optional(),
+  retryAfterSeconds: z5.number().int().positive().optional()
+});
+var customMcpConnectionBlockSchema = z5.object({
+  authKind: customMcpAuthKindSchema,
+  /** `URL.host`, port included. */
+  host: z5.string(),
+  /** Host plus a masked path; never the URL. */
+  urlDisplay: z5.string(),
+  /** Names only, for the edit form. Present on `headers` connections. */
+  headerNames: z5.array(z5.string()).optional(),
+  /** The workflow connection key that names this server: {@link customMcpWorkflowKey} of its display name. */
+  workflowKey: z5.string().regex(WORKFLOW_CONNECTION_KEY_RE).optional(),
+  health: customMcpHealthSchema,
+  toolCount: nonNegativeInt,
+  enabledToolCount: nonNegativeInt
+});
+var customMcpConnectionViewSchema = z5.object({
+  id: customMcpConnectionIdSchema,
+  displayName: z5.string(),
+  ownerType: z5.enum([
+    "user",
+    "agent"
+  ]),
+  agentId: z5.string().optional(),
+  customMcp: customMcpConnectionBlockSchema
+});
+var customMcpConnectionResponseSchema = z5.object({
+  connection: customMcpConnectionViewSchema
+});
+var customMcpProbeBodySchema = z5.object({
+  url: customMcpUrlInputSchema,
+  headers: customMcpHeadersSchema.optional()
+}).strict();
+var customMcpOAuthDiscoverySchema = z5.object({
+  issuer: z5.string().url(),
+  scopes: z5.array(z5.string()),
+  /** `manual_required`: neither CIMD nor DCR; the person registers a client with `callbackUrl`. */
+  registration: z5.enum([
+    "cimd",
+    "dcr",
+    "manual_required"
+  ]),
+  callbackUrl: z5.string().url()
+});
+var customMcpProbeResponseSchema = z5.discriminatedUnion("outcome", [
+  z5.object({
+    outcome: z5.literal("connected"),
+    authKind: z5.enum([
+      "none",
+      "headers"
+    ]),
+    serverInfo: customMcpServerInfoSchema,
+    tools: z5.array(customMcpToolSchema)
+  }),
+  /** The server challenged and publishes usable OAuth metadata. */
+  z5.object({
+    outcome: z5.literal("sign_in_required"),
+    oauth: customMcpOAuthDiscoverySchema
+  }),
+  /** The server challenged without usable OAuth and no headers were sent. */
+  z5.object({
+    outcome: z5.literal("credentials_required"),
+    httpStatus: z5.number().int()
+  })
+]);
+var createFields = {
+  url: customMcpUrlInputSchema,
+  displayName: customMcpDisplayNameSchema,
+  timeout: customMcpTimeoutSchema.optional(),
+  /** Defaults to allow-all. */
+  tools: customMcpToolSelectionSchema.optional()
+};
+var mountAgentField = {
+  mountAgentId: agentId.optional()
+};
+function createBody(extra) {
+  return z5.discriminatedUnion("authKind", [
+    z5.object({
+      authKind: z5.literal("none"),
+      ...createFields,
+      ...extra
+    }).strict(),
+    z5.object({
+      authKind: z5.literal("headers"),
+      headers: customMcpHeadersSchema.refine((headers) => Object.keys(headers).length > 0, "Add a header"),
+      ...createFields,
+      ...extra
+    }).strict()
+  ]);
+}
+__name(createBody, "createBody");
+__name3(createBody, "createBody");
+var customMcpCreateAgentBodySchema = createBody({});
+var customMcpCreateUserBodySchema = createBody(mountAgentField);
+var customMcpOAuthClientSchema = z5.object({
+  clientId: z5.string().trim().min(1).max(512),
+  clientSecret: z5.string().min(1).max(2048).optional()
+}).strict();
+var startFields = {
+  successRedirect: z5.string().max(CUSTOM_MCP_URL_MAX_LENGTH),
+  failureRedirect: z5.string().max(CUSTOM_MCP_URL_MAX_LENGTH),
+  state: z5.string().max(256),
+  client: customMcpOAuthClientSchema.optional()
+};
+function startBody(extra) {
+  return z5.union([
+    z5.object({
+      url: customMcpUrlInputSchema,
+      displayName: customMcpDisplayNameSchema,
+      ...startFields,
+      ...extra
+    }).strict(),
+    /** Sign in again. `url` only after `REAUTH_REQUIRED`; otherwise the stored URL is used. */
+    z5.object({
+      targetConnectionId: customMcpConnectionIdSchema,
+      url: customMcpUrlInputSchema.optional(),
+      ...startFields
+    }).strict()
+  ]);
+}
+__name(startBody, "startBody");
+__name3(startBody, "startBody");
+var customMcpOAuthStartAgentBodySchema = startBody({});
+var customMcpOAuthStartUserBodySchema = startBody(mountAgentField);
+var customMcpOAuthStartResponseSchema = z5.object({
+  authUrl: z5.string().url(),
+  pendingId: z5.string().min(1),
+  expiresAt: isoDateTime,
+  registration: customMcpOAuthRegistrationSchema
+});
+var nonce = z5.string().regex(/^[A-Za-z0-9_-]{32,128}$/);
+var customMcpOAuthSuccessRedirectQuerySchema = z5.object({
+  state: z5.string(),
+  id: z5.string().min(1),
+  nonce
+});
+var CUSTOM_MCP_OAUTH_CALLBACK_ERRORS = [
+  "access_denied",
+  "authorize",
+  "token_exchange",
+  "expired"
+];
+var customMcpOAuthFailureRedirectQuerySchema = z5.object({
+  state: z5.string(),
+  error: z5.enum(CUSTOM_MCP_OAUTH_CALLBACK_ERRORS),
+  ref: customMcpReferenceIdSchema
+});
+var customMcpOAuthFinalizeBodySchema = z5.object({
+  pendingId: z5.string().min(1).max(128),
+  nonce,
+  tools: customMcpToolSelectionSchema.optional()
+}).strict();
+var customMcpCimdDocumentSchema = z5.object({
+  client_id: z5.string().url(),
+  client_name: z5.string(),
+  client_uri: z5.string().url().optional(),
+  logo_uri: z5.string().url().optional(),
+  redirect_uris: z5.array(z5.string().url()).min(1),
+  grant_types: z5.array(z5.enum([
+    "authorization_code",
+    "refresh_token"
+  ])),
+  response_types: z5.array(z5.literal("code")),
+  token_endpoint_auth_method: z5.literal("none")
+});
+var customMcpPatchBodySchema = z5.object({
+  displayName: customMcpDisplayNameSchema.optional(),
+  url: customMcpUrlInputSchema.optional(),
+  headers: customMcpHeadersPatchSchema.optional(),
+  timeout: customMcpTimeoutSchema.optional()
+}).strict().refine((body) => Object.values(body).some((value3) => value3 !== void 0), {
+  message: "Nothing to change"
+});
+var customMcpCredentialRequestSchema = z5.object({
+  mode: z5.enum([
+    "mount",
+    "room_personal"
+  ]),
+  connectionId: customMcpConnectionIdSchema,
+  agentId,
+  /** The server rejected this token version: refresh unless it is already stale. */
+  rejectedTokenVersion: nonNegativeInt.optional()
+}).strict();
+var customMcpCredentialAuthSchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("none")
+  }),
+  z5.object({
+    kind: z5.literal("headers"),
+    headers: z5.record(z5.string(), z5.string())
+  }),
+  z5.object({
+    kind: z5.literal("oauth"),
+    accessToken: z5.string().min(1),
+    tokenVersion: nonNegativeInt,
+    /** At least {@link CUSTOM_MCP_ACCESS_TOKEN_MIN_REMAINING_MS} away. */
+    expiresAt: isoDateTime
+  })
+]);
+var customMcpCredentialResponseSchema = z5.object({
+  connectionId: customMcpConnectionIdSchema,
+  credentialGeneration: nonNegativeInt,
+  url: z5.string().url(),
+  auth: customMcpCredentialAuthSchema
+});
+var CUSTOM_MCP_CREDENTIAL_ERRORS = {
+  /** 403. Not mounted on this agent, or the room grant is no longer current. */
+  NOT_MOUNTED: "NOT_MOUNTED",
+  /** 404. */
+  NOT_FOUND: "NOT_FOUND",
+  /** 409. Paused by its owner. */
+  PAUSED: "PAUSED",
+  /** 409. The refresh token is gone or was refused; the owner must sign in again. */
+  NEEDS_SIGN_IN: "NEEDS_SIGN_IN",
+  /** 503. The token endpoint failed; retry later. */
+  REFRESH_UNAVAILABLE: "REFRESH_UNAVAILABLE"
+};
+var customMcpCredentialErrorBodySchema = z5.object({
+  code: z5.nativeEnum(CUSTOM_MCP_CREDENTIAL_ERRORS),
+  message: z5.string()
+});
+var customMcpHealthReportSchema = z5.object({
+  reports: z5.array(z5.object({
+    connectionId: customMcpConnectionIdSchema,
+    agentId,
+    credentialGeneration: nonNegativeInt,
+    tokenVersion: nonNegativeInt.optional(),
+    outcome: z5.enum([
+      "ok",
+      "failure"
+    ]),
+    failure: z5.object({
+      step: customMcpConnectStepSchema,
+      code: customMcpFailureCodeSchema,
+      httpStatus: z5.number().int().min(100).max(599).optional(),
+      referenceId: customMcpReferenceIdSchema
+    }).strict().optional(),
+    observedAt: isoDateTime
+  }).strict().refine((report) => report.outcome === "failure" === (report.failure !== void 0), {
+    path: [
+      "failure"
+    ],
+    message: "A failure report carries `failure`; an ok report does not"
+  })).min(1).max(50)
+}).strict();
+var customMcpProbeRequestSchema = z5.object({
+  url: z5.string().url().max(CUSTOM_MCP_URL_MAX_LENGTH),
+  auth: z5.discriminatedUnion("kind", [
+    z5.object({
+      kind: z5.literal("none")
+    }).strict(),
+    z5.object({
+      kind: z5.literal("headers"),
+      headers: customMcpHeadersSchema
+    }).strict(),
+    z5.object({
+      kind: z5.literal("bearer"),
+      accessToken: z5.string().min(1)
+    }).strict()
+  ]),
+  timeout: customMcpTimeoutSchema.optional(),
+  referenceId: customMcpReferenceIdSchema
+}).strict();
+var customMcpProbeResultSchema = z5.discriminatedUnion("ok", [
+  z5.object({
+    ok: z5.literal(true),
+    serverInfo: customMcpServerInfoSchema,
+    tools: z5.array(customMcpToolSchema).max(CUSTOM_MCP_MAX_TOOLS),
+    protocolVersion: z5.string().optional()
+  }),
+  z5.object({
+    ok: z5.literal(false),
+    step: customMcpConnectStepSchema,
+    code: customMcpFailureCodeSchema,
+    httpStatus: z5.number().int().min(100).max(599).optional(),
+    /** The 401/403 challenge, raw, for lua-api's OAuth discovery. */
+    wwwAuthenticate: z5.string().max(4096).optional()
+  })
+]);
+var customMcpOriginUrlSchema = z5.string().url().refine((value3) => {
+  try {
+    const url = new URL(value3);
+    return url.protocol === "https:" && url.pathname === "/" && !url.search && !url.hash && !url.username && !url.password;
+  } catch {
+    return false;
+  }
+}, "Origin only");
+var customMcpServerProjectionSchema = z5.object({
+  name: z5.string().min(1),
+  runtimeKey: z5.string().min(1),
+  transport: z5.literal(CUSTOM_MCP_TRANSPORT),
+  source: z5.literal(CUSTOM_MCP_SOURCE),
+  url: customMcpOriginUrlSchema,
+  connectionId: customMcpConnectionIdSchema,
+  connectionLabel: z5.string(),
+  /** The connection's owner kind, for the dashboard's "Personal" label. */
+  ownerType: z5.enum([
+    "user",
+    "agent"
+  ]),
+  authKind: customMcpAuthKindSchema,
+  credentialGeneration: nonNegativeInt,
+  tools: z5.object({
+    allow: z5.array(z5.string())
+  }).optional(),
+  timeout: z5.number().int().positive()
+});
+var customMcpMountUpsertBodySchema = z5.object({
+  source: z5.literal(CUSTOM_MCP_SOURCE),
+  transport: z5.literal(CUSTOM_MCP_TRANSPORT),
+  url: customMcpOriginUrlSchema,
+  connectionId: customMcpConnectionIdSchema,
+  connectionLabel: z5.string(),
+  ownerType: z5.enum([
+    "user",
+    "agent"
+  ]),
+  authKind: customMcpAuthKindSchema,
+  credentialGeneration: nonNegativeInt,
+  tools: z5.object({
+    allow: z5.array(customMcpToolNameSchema).max(CUSTOM_MCP_MAX_TOOLS)
+  }).strict().optional(),
+  timeout: customMcpTimeoutSchema.optional()
+}).strict();
+function maskMcpServerHeaders(server) {
+  const { headers, ...rest } = server;
+  const headerNames = Object.keys(headers ?? {});
+  return {
+    ...rest,
+    headerNames,
+    headersSet: headerNames.length > 0
+  };
+}
+__name(maskMcpServerHeaders, "maskMcpServerHeaders");
+__name3(maskMcpServerHeaders, "maskMcpServerHeaders");
 
 // ../workflow-graph/dist/index.mjs
 import { createHash } from "crypto";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { z as z22 } from "zod";
 import { createHash as createHash2 } from "crypto";
 var __defProp4 = Object.defineProperty;
@@ -11168,8 +11778,8 @@ var rows = /* @__PURE__ */ __name4((s, path, page) => ({
 var fromKnowledge = /* @__PURE__ */ __name4((k) => ({
   knowledge: k
 }), "fromKnowledge");
-var SideEffectsSchema = z5.enum(WORKFLOW_SIDE_EFFECTS);
-var JobResourcesSchema = z5.enum(WORKFLOW_JOB_RESOURCES);
+var SideEffectsSchema = z6.enum(WORKFLOW_SIDE_EFFECTS);
+var JobResourcesSchema = z6.enum(WORKFLOW_JOB_RESOURCES);
 var WORKFLOW_MODEL_TEMPLATE_ROOT = "initData";
 var WORKFLOW_MODEL_TEMPLATE_RE = /^\$\{\s*initData\.([A-Za-z0-9_.\-[\]]+)\s*(?:\|([^}]*))?\}$/;
 var PATH_SEGMENT_RE = /^[A-Za-z0-9_-]+(?:\[(?:0|[1-9]\d*)\])*$/;