@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-2OP6WLGV.js

@@ -0,0 +1,708 @@
+"use client";
+import {
+  DEFAULT_CADENCE_TIME,
+  cadenceFromScheduleSpec,
+  describeCadence,
+  formatRunTime,
+  nextRuns,
+  toScheduleSpec,
+  validateCadence
+} from "./chunk-6JHU2UBS.js";
+import {
+  inSentence
+} from "./chunk-53AGXXZM.js";
+import {
+  sessionAutomationWait,
+  sessionAutomationWaitLabel
+} from "./chunk-3PZ7JZI2.js";
+
+// src/components/automations/event-trigger-model.ts
+import {
+  DEFAULT_EVENT_RUNS_PER_HOUR,
+  EVENT_CONDITION_FIELD_PATTERN,
+  EVENT_TRIGGER_CONDITIONS_MAX,
+  EVENT_TRIGGER_TYPES_MAX,
+  EVENT_TRIGGERS_PER_AUTOMATION_MAX,
+  EVENT_TYPE_MAX_LENGTH,
+  MAX_EVENT_RUNS_PER_HOUR
+} from "@opengeni/contracts/event-triggers";
+var draftKeySequence = 0;
+function draftKey(prefix) {
+  draftKeySequence += 1;
+  return `${prefix}-${draftKeySequence}`;
+}
+function emptyEventTriggersDraft() {
+  return { triggers: [], once: false, maxRunsPerHour: DEFAULT_EVENT_RUNS_PER_HOUR };
+}
+function newEventTriggerDraft(sourceId = "") {
+  return {
+    key: draftKey("trigger"),
+    sourceId,
+    eventTypes: [],
+    conditions: [],
+    includeOwnEvents: false,
+    argumentsText: ""
+  };
+}
+function newEventConditionDraft(field = "") {
+  return { key: draftKey("condition"), field, op: "equals", value: "" };
+}
+function conditionValueText(value) {
+  if (value === void 0) return "";
+  if (Array.isArray(value)) return value.map((entry) => scalarText(entry)).join(", ");
+  return scalarText(value);
+}
+function scalarText(value) {
+  return value === null ? "null" : String(value);
+}
+function eventConditionDraftFrom(condition) {
+  return {
+    key: draftKey("condition"),
+    field: condition.field,
+    op: condition.op,
+    value: conditionValueText(condition.value)
+  };
+}
+function eventTriggerDraftFrom(trigger) {
+  return {
+    key: draftKey("trigger"),
+    sourceId: trigger.sourceId,
+    eventTypes: [...trigger.eventTypes],
+    conditions: trigger.conditions.map(eventConditionDraftFrom),
+    includeOwnEvents: trigger.includeOwnEvents,
+    argumentsText: trigger.arguments && Object.keys(trigger.arguments).length > 0 ? JSON.stringify(trigger.arguments, null, 2) : ""
+  };
+}
+function eventTriggersDraftFrom(events) {
+  if (!events) return emptyEventTriggersDraft();
+  return {
+    triggers: events.triggers.map(eventTriggerDraftFrom),
+    once: events.once,
+    maxRunsPerHour: events.maxRunsPerHour
+  };
+}
+var EVENT_CONDITION_OPERATORS = [
+  { value: "equals", takes: "one" },
+  { value: "not_equals", takes: "one" },
+  { value: "in", takes: "list" },
+  { value: "not_in", takes: "list" },
+  { value: "contains", takes: "one" },
+  { value: "exists", takes: null },
+  { value: "not_exists", takes: null }
+];
+function eventConditionOperator(op) {
+  return EVENT_CONDITION_OPERATORS.find((option) => option.value === op);
+}
+function eventConditionOperatorLabel(t, op) {
+  switch (op) {
+    case "equals":
+      return t("automations.condition.op.equals");
+    case "not_equals":
+      return t("automations.condition.op.notEquals");
+    case "in":
+      return t("automations.condition.op.in");
+    case "not_in":
+      return t("automations.condition.op.notIn");
+    case "contains":
+      return t("automations.condition.op.contains");
+    case "exists":
+      return t("automations.condition.op.exists");
+    case "not_exists":
+      return t("automations.condition.op.notExists");
+  }
+}
+function eventCommonFields(t) {
+  return [
+    { field: "subject", description: t("automations.field.subject") },
+    { field: "summary", description: t("automations.field.summary") },
+    { field: "actor.name", description: t("automations.field.actorName") },
+    { field: "actor.kind", description: t("automations.field.actorKind") },
+    { field: "url", description: t("automations.field.url") }
+  ];
+}
+function parseScalar(text) {
+  if (text === "true") return true;
+  if (text === "false") return false;
+  return text;
+}
+function eventConditionFromDraft(draft) {
+  const takes = eventConditionOperator(draft.op).takes;
+  const field = draft.field.trim();
+  if (takes === null) return { field, op: draft.op };
+  if (takes === "list") {
+    return {
+      field,
+      op: draft.op,
+      value: draft.value.split(",").map((entry) => entry.trim()).filter(Boolean).map(parseScalar)
+    };
+  }
+  return { field, op: draft.op, value: parseScalar(draft.value.trim()) };
+}
+function eventTriggersInputFrom(draft) {
+  return {
+    triggers: draft.triggers.map((trigger) => {
+      const args = parseArguments(trigger.argumentsText);
+      return {
+        sourceId: trigger.sourceId,
+        eventTypes: trigger.eventTypes,
+        conditions: trigger.conditions.map(eventConditionFromDraft),
+        includeOwnEvents: trigger.includeOwnEvents,
+        ...args.ok && args.value ? { arguments: args.value } : {}
+      };
+    }),
+    maxRunsPerHour: draft.maxRunsPerHour,
+    once: draft.once
+  };
+}
+function sameEventTriggers(left, right) {
+  const normalized = (draft) => draft.triggers.length === 0 ? { triggers: [] } : eventTriggersInputFrom(draft);
+  return JSON.stringify(normalized(left)) === JSON.stringify(normalized(right));
+}
+function parseArguments(text) {
+  if (!text.trim()) return { ok: true, value: null };
+  try {
+    const value = JSON.parse(text);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return { ok: true, value };
+    }
+    return { ok: false };
+  } catch {
+    return { ok: false };
+  }
+}
+var EVENT_TYPE_PATTERN = /^[\x21-\x7e]+$/u;
+function eventTypeIssue(t, type) {
+  if (!type) return t("automations.issue.eventTypeEmpty");
+  if (type.length > EVENT_TYPE_MAX_LENGTH) return t("automations.issue.eventTypeTooLong");
+  if (!EVENT_TYPE_PATTERN.test(type)) return t("automations.issue.eventTypeSpaces");
+  return null;
+}
+function validateEventTriggers(t, draft, sources) {
+  const issues = { triggers: {} };
+  for (const trigger of draft.triggers) {
+    const found = {};
+    const source = sources.find((candidate) => candidate.id === trigger.sourceId);
+    if (!trigger.sourceId) found.source = t("automations.issue.source");
+    else if (!source) found.source = t("automations.issue.sourceGone");
+    if (trigger.eventTypes.length === 0) found.eventTypes = t("automations.issue.eventTypesEmpty");
+    else if (source?.kind === "mcp" && trigger.eventTypes.length > 1)
+      found.eventTypes = t("automations.issue.mcpOneEvent");
+    else if (trigger.eventTypes.length > EVENT_TRIGGER_TYPES_MAX)
+      found.eventTypes = t("automations.issue.eventTypesTooMany", { max: EVENT_TRIGGER_TYPES_MAX });
+    if (!parseArguments(trigger.argumentsText).ok)
+      found.arguments = t("automations.issue.arguments");
+    const conditionIssues = {};
+    for (const condition of trigger.conditions) {
+      const field = condition.field.trim();
+      const takes = eventConditionOperator(condition.op).takes;
+      if (!field) conditionIssues[condition.key] = t("automations.issue.conditionField");
+      else if (!EVENT_CONDITION_FIELD_PATTERN.test(field))
+        conditionIssues[condition.key] = t("automations.issue.conditionFieldPattern");
+      else if (takes !== null && !condition.value.trim())
+        conditionIssues[condition.key] = takes === "list" ? t("automations.issue.conditionValues") : t("automations.issue.conditionValue");
+    }
+    if (Object.keys(conditionIssues).length > 0) found.conditions = conditionIssues;
+    if (Object.keys(found).length > 0) issues.triggers[trigger.key] = found;
+  }
+  if (!Number.isInteger(draft.maxRunsPerHour) || draft.maxRunsPerHour < 1 || draft.maxRunsPerHour > MAX_EVENT_RUNS_PER_HOUR) {
+    issues.maxRunsPerHour = t("automations.issue.maxRunsPerHour", {
+      max: MAX_EVENT_RUNS_PER_HOUR
+    });
+  }
+  return issues;
+}
+function hasEventTriggerIssues(issues) {
+  return Object.keys(issues.triggers).length > 0 || issues.maxRunsPerHour !== void 0;
+}
+function eventTypeLabel(t, type) {
+  if (type === "*") return t("automations.eventType.every");
+  if (type.endsWith(".*"))
+    return t("automations.eventType.everyPrefix", { prefix: type.slice(0, -2) });
+  return type;
+}
+function eventTypesLabel(t, types) {
+  if (types.length === 0) return t("automations.eventTypes.none");
+  const first = eventTypeLabel(t, types[0]);
+  if (types.length === 1) return first;
+  if (types.length === 2)
+    return t("automations.eventTypes.either", { first, second: eventTypeLabel(t, types[1]) });
+  return t("automations.eventTypes.firstAndMore", { first, count: types.length - 1 });
+}
+function eventConditionsLabel(t, conditions) {
+  if (conditions.length === 0) return null;
+  if (conditions.length > 1)
+    return t("automations.conditions.onlyWhenCount", { count: conditions.length });
+  const [condition] = conditions;
+  const operator = eventConditionOperatorLabel(t, condition.op);
+  if (eventConditionOperator(condition.op).takes === null)
+    return t("automations.conditions.onlyWhenSet", { field: condition.field, operator });
+  return t("automations.conditions.onlyWhen", {
+    field: condition.field,
+    operator,
+    value: conditionValueText(condition.value)
+  });
+}
+function eventTriggerWords(t, trigger, sources) {
+  const source = sources.find((candidate) => candidate.id === trigger.sourceId)?.name;
+  const events = eventTypesLabel(t, trigger.eventTypes);
+  return {
+    source: source ?? t("automations.trigger.hiddenSource"),
+    events,
+    conditions: eventConditionsLabel(t, trigger.conditions),
+    short: t("automations.trigger.short", {
+      events,
+      source: source ?? t("automations.trigger.hiddenSourceInline")
+    })
+  };
+}
+function eventTriggersShortLabel(t, triggers, sources) {
+  const [first] = triggers;
+  if (!first) return null;
+  const words = eventTriggerWords(t, first, sources).short;
+  return triggers.length === 1 ? words : t("automations.triggers.shortAndMore", { words, count: triggers.length - 1 });
+}
+function eventTypeDescriptor(type, descriptors) {
+  return descriptors.find((descriptor) => descriptor.type === type);
+}
+function eventConditionFieldSuggestions(t, eventTypes, descriptors) {
+  const picked = descriptors.filter((descriptor) => eventTypes.includes(descriptor.type));
+  const seen = /* @__PURE__ */ new Set();
+  const fields = [];
+  for (const entry of [
+    ...picked.flatMap((descriptor) => descriptor.fields),
+    ...eventCommonFields(t)
+  ]) {
+    if (seen.has(entry.field)) continue;
+    seen.add(entry.field);
+    fields.push(entry);
+  }
+  return fields;
+}
+
+// src/components/automations/automation-model.ts
+function viewerTimeZone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+function defaultAutomationCadence(timeZone = viewerTimeZone()) {
+  return { timeZone, rule: { frequency: "weekdays", time: DEFAULT_CADENCE_TIME } };
+}
+function automationCadence(schedule, fallbackTimeZone = viewerTimeZone()) {
+  if (schedule.type === "manual") return null;
+  try {
+    return cadenceFromScheduleSpec(
+      schedule,
+      "timeZone" in schedule && schedule.timeZone ? schedule.timeZone : fallbackTimeZone
+    );
+  } catch {
+    return null;
+  }
+}
+function automationScheduleSpec(cadence, now) {
+  if (!cadence) return { type: "manual" };
+  return toScheduleSpec(cadence.rule, {
+    timeZone: cadence.timeZone,
+    now
+  });
+}
+function automationCadenceWords(t, cadence, now) {
+  const words = describeCadence(cadence.rule, { timeZone: cadence.timeZone, now, text: t });
+  return { short: words.short, sentence: words.sentence };
+}
+function automationScheduleWords(t, schedule, now) {
+  const cadence = automationCadence(schedule);
+  if (!cadence) {
+    return { short: t("automations.when.manual"), sentence: t("automations.when.manualSentence") };
+  }
+  return automationCadenceWords(t, cadence, now);
+}
+function automationCadenceIssue(t, cadence, now) {
+  if (!cadence) return null;
+  return validateCadence(cadence.rule, { timeZone: cadence.timeZone, now, text: t })?.message ?? null;
+}
+function automationCadenceRepeats(cadence) {
+  return cadence !== null && cadence.rule.frequency !== "once";
+}
+function hasEventTriggers(task) {
+  return (task.events?.triggers.length ?? 0) > 0;
+}
+function isFinishedOnce(task) {
+  return Boolean(task.events?.once && task.events.completedAt);
+}
+function automationNextRun(task, now) {
+  if (task.status !== "active" || isFinishedOnce(task)) return null;
+  const cadence = automationCadence(task.schedule);
+  if (!cadence) return null;
+  return nextRuns(cadence.rule, { timeZone: cadence.timeZone, now, count: 1 })[0] ?? null;
+}
+function automationListensForEvents(task) {
+  return task.status === "active" && hasEventTriggers(task) && !isFinishedOnce(task);
+}
+function isAgentAutomation(task) {
+  return task.action?.kind !== "knowledge_source_sync" && !task.agentConfig?.knowledgeSource;
+}
+function sortAutomations(tasks, now) {
+  const keyed = tasks.map((task) => ({
+    task,
+    next: automationNextRun(task, now)?.getTime() ?? null,
+    listening: automationListensForEvents(task)
+  }));
+  const rank = (entry) => entry.next !== null ? 0 : entry.listening ? 1 : 2;
+  keyed.sort((left, right) => {
+    if (rank(left) !== rank(right)) return rank(left) - rank(right);
+    if (left.next !== null && right.next !== null && left.next !== right.next)
+      return left.next - right.next;
+    return left.task.name.localeCompare(right.task.name);
+  });
+  return keyed.map((entry) => entry.task);
+}
+function automationWhenWords(t, task, sources, now) {
+  const events = eventTriggersShortLabel(t, task.events?.triggers ?? [], sources);
+  if (!events) return automationScheduleWords(t, task.schedule, now).short;
+  if (task.schedule.type === "manual") return events;
+  return t("automations.when.scheduleAndEvents", {
+    schedule: automationScheduleWords(t, task.schedule, now).short,
+    events
+  });
+}
+function automationWhenSentence(t, task, now) {
+  const words = automationScheduleWords(t, task.schedule, now).sentence;
+  if (!hasEventTriggers(task)) return t("automations.when.sentence", { words });
+  if (task.schedule.type !== "manual") return t("automations.when.sentenceWithEvents", { words });
+  return task.events?.once ? t("automations.when.onceOnEvent") : t("automations.when.onEvent");
+}
+function automationRunEventsLabel(t, run) {
+  const occurrence = run.eventOccurrence;
+  if (!occurrence || occurrence.eventCount === 0) return null;
+  const [first] = occurrence.events;
+  if (!first) return t("automations.runEvents.count", { count: occurrence.eventCount });
+  const what = first.summary ?? first.subject ?? first.type;
+  return occurrence.eventCount === 1 ? what : t("automations.runEvents.firstAndMore", { first: what, count: occurrence.eventCount - 1 });
+}
+function automationRunStatusLabel(t, status) {
+  switch (status) {
+    case "queued":
+      return t("automations.run.status.queued");
+    case "dispatched":
+      return t("automations.run.status.dispatched");
+    case "succeeded":
+      return t("automations.run.status.succeeded");
+    case "skipped":
+      return t("automations.run.status.skipped");
+    case "failed":
+      return t("automations.run.status.failed");
+  }
+}
+function automationRunTriggerLabel(t, triggerType) {
+  switch (triggerType) {
+    case "scheduled":
+      return t("automations.run.trigger.scheduled");
+    case "manual":
+      return t("automations.run.trigger.manual");
+    case "initial":
+      return t("automations.run.trigger.initial");
+    case "provider_event":
+      return t("automations.run.trigger.providerEvent");
+    case "event":
+      return t("automations.run.trigger.event");
+    case "retry":
+      return t("automations.run.trigger.retry");
+    case "repair":
+      return t("automations.run.trigger.repair");
+  }
+}
+var RUN_ERROR_KEYS = {
+  scheduled_turn_failed: "automations.run.error.turnFailed",
+  scheduled_update_failed: "automations.run.error.turnFailed",
+  scheduled_turn_cancelled: "automations.run.error.turnStopped",
+  scheduled_update_cancelled: "automations.run.error.turnStopped",
+  scheduled_turn_superseded: "automations.run.error.turnInterrupted",
+  scheduled_update_superseded: "automations.run.error.turnInterrupted",
+  scheduled_turn_withdrawn_for_edit: "automations.run.error.turnWithdrawn",
+  scheduled_session_not_idle: "automations.run.error.chatBusy",
+  scheduled_session_waiting_capacity: "automations.run.error.chatWaitingForAccount",
+  scheduled_session_paused: "automations.run.error.chatPaused",
+  session_cancelled: "automations.run.error.chatEnded",
+  scheduled_target_session_unavailable: "automations.run.error.chatGone",
+  scheduled_target_execution_changed: "automations.run.error.chatChanged",
+  scheduled_workspace_paused: "automations.run.error.workspacePaused",
+  scheduled_task_paused_before_claim: "automations.run.error.automationInactive",
+  scheduled_task_deleted_before_claim: "automations.run.error.automationInactive",
+  scheduled_task_inactive_before_claim: "automations.run.error.automationInactive",
+  scheduled_machine_unavailable: "automations.run.error.machineUnavailable",
+  machine_target_unavailable: "automations.run.error.machineUnavailable",
+  machine_enrollment_inactive: "automations.run.error.machineUnavailable",
+  scheduled_authority_unavailable: "automations.run.error.accessUnavailable",
+  scheduled_authority_exhausted: "automations.run.error.accessUnavailable",
+  scheduled_authority_snapshot_missing: "automations.run.error.accessUnavailable",
+  scheduled_run_authority_proof_rejected: "automations.run.error.accessUnavailable",
+  scheduled_causal_membership_changed: "automations.run.error.accessUnavailable",
+  connection_account_unavailable: "automations.run.error.accountUnavailable",
+  scheduled_model_unavailable: "automations.run.error.modelUnavailable",
+  rig_version_unavailable: "automations.run.error.rigUnavailable",
+  insufficient_credits: "automations.run.error.outOfCredits",
+  allowance_exhausted: "automations.run.error.allowanceUsed",
+  monthly_model_cost_limit: "automations.run.error.monthlyCostLimit",
+  monthly_agent_run_limit: "automations.run.error.monthlyRunLimit",
+  session_usage_limit: "automations.run.error.usageLimit",
+  chain_limit: "automations.run.error.chainLimit"
+};
+var MODEL_UNAVAILABLE_TEXT = /^(?:model is not available: .+|Turn execution policy model is (?:not present in the configured catalog|retired from new selection|no longer configured))$/;
+var REASON_CODE = /^[a-z][a-z0-9_]*$/;
+function automationRunErrorText(t, error) {
+  const trimmed = error.trim();
+  const key = Object.hasOwn(RUN_ERROR_KEYS, trimmed) ? RUN_ERROR_KEYS[trimmed] : void 0;
+  if (key) return t(key);
+  if (MODEL_UNAVAILABLE_TEXT.test(trimmed)) return t("automations.run.error.modelUnavailable");
+  if (!trimmed || REASON_CODE.test(trimmed)) return t("automations.run.error.unknown");
+  return trimmed;
+}
+var AUTOMATION_NAME_MAX_LENGTH = 80;
+var DANGLING_WORD = /\s+(a|an|and|at|by|for|from|in|into|of|on|or|the|to|with)$/i;
+var DERIVED_NAME_LIMIT = 60;
+function deriveAutomationName(instructions) {
+  const withoutCadence = instructions.trim().replace(/^every\b.{0,40}?:\s+/i, "");
+  const firstSentence = withoutCadence.split(/(?<=[.!?])\s|\n/)[0]?.replace(/[.!?]$/, "") ?? "";
+  const clean = firstSentence.replace(/\s+/g, " ").trim();
+  if (!clean) return "";
+  const capitalized = clean.charAt(0).toLocaleUpperCase() + clean.slice(1);
+  if (capitalized.length <= DERIVED_NAME_LIMIT) return capitalized;
+  let cut = capitalized.slice(0, DERIVED_NAME_LIMIT);
+  const space = cut.lastIndexOf(" ");
+  if (space > 20) cut = cut.slice(0, space);
+  cut = cut.replace(/[,;:]$/, "");
+  while (DANGLING_WORD.test(cut)) cut = cut.replace(DANGLING_WORD, "");
+  return `${cut}\u2026`;
+}
+function newAutomationDraft(options = {}) {
+  return {
+    instructions: "",
+    name: "",
+    cadence: options.cadence === void 0 ? defaultAutomationCadence() : options.cadence,
+    events: emptyEventTriggersDraft()
+  };
+}
+function automationDraftFrom(task) {
+  return {
+    instructions: task.agentConfig.prompt,
+    name: task.name,
+    cadence: automationCadence(task.schedule),
+    events: eventTriggersDraftFrom(task.events)
+  };
+}
+function automationName(t, draft) {
+  return draft.name.trim() || deriveAutomationName(draft.instructions) || t("automations.name.untitled");
+}
+function validateAutomationDraft(t, draft, sources, now) {
+  const issues = {};
+  if (!draft.instructions.trim()) issues.instructions = t("automations.issue.instructions");
+  if (draft.name.trim().length > AUTOMATION_NAME_MAX_LENGTH)
+    issues.name = t("automations.issue.nameTooLong", { max: AUTOMATION_NAME_MAX_LENGTH });
+  const cadence = automationCadenceIssue(t, draft.cadence, now);
+  if (cadence) issues.cadence = cadence;
+  if (draft.events.once && draft.events.triggers.length > 0 && automationCadenceRepeats(draft.cadence))
+    issues.when = t("automations.issue.onceRepeats");
+  if (draft.events.triggers.length > 0) {
+    const events = validateEventTriggers(t, draft.events, sources);
+    if (hasEventTriggerIssues(events)) issues.events = events;
+  }
+  return issues;
+}
+function hasAutomationDraftIssues(issues) {
+  return Object.values(issues).some(Boolean);
+}
+function eventsForCreate(draft) {
+  return draft.events.triggers.length > 0 ? { events: eventTriggersInputFrom(draft.events) } : {};
+}
+function automationCreateRequest(t, draft, destination, now) {
+  const name = automationName(t, draft);
+  const schedule = automationScheduleSpec(draft.cadence, now);
+  const prompt = draft.instructions.trim();
+  if (destination.kind === "chat") {
+    return {
+      name,
+      schedule,
+      prompt,
+      targetSessionId: destination.sessionId,
+      ...eventsForCreate(draft)
+    };
+  }
+  return {
+    name,
+    schedule,
+    runMode: "new_session_per_run",
+    agentConfig: {
+      prompt,
+      resources: [],
+      tools: [],
+      toolPolicy: { mode: "workspace_default", excludedMcpServerIds: [] },
+      executionTarget: "workspace_default",
+      metadata: {}
+    },
+    ...eventsForCreate(draft)
+  };
+}
+function automationUpdateRequest(t, initial, draft, now) {
+  const name = automationName(t, draft);
+  return {
+    ...automationName(t, initial) === name ? {} : { name },
+    ...initial.instructions.trim() === draft.instructions.trim() ? {} : { prompt: draft.instructions.trim() },
+    ...JSON.stringify(initial.cadence) === JSON.stringify(draft.cadence) ? {} : { schedule: automationScheduleSpec(draft.cadence, now) },
+    // Triggers are sent whole, and only when they changed; none removes them all.
+    ...sameEventTriggers(initial.events, draft.events) ? {} : {
+      events: draft.events.triggers.length > 0 ? eventTriggersInputFrom(draft.events) : { triggers: [] }
+    }
+  };
+}
+var WAIT_CHIP_SOURCES = 2;
+function listWords(t, items, type) {
+  try {
+    return new Intl.ListFormat(t.locale, { type }).format(items);
+  } catch {
+    return items.join(", ");
+  }
+}
+function waitEventWords(t, event) {
+  const types = eventTypesLabel(t, event.eventTypes);
+  return t("automations.trigger.short", {
+    // "Every event" reads "every event" mid-sentence; event names keep their case.
+    events: event.eventTypes[0]?.endsWith("*") ? inSentence(types, t) : types,
+    source: event.source?.name ?? t("automations.trigger.hiddenSourceInline")
+  });
+}
+function waitSourcesShort(t, events) {
+  const names = events.flatMap((event) => event.source ? [event.source.name] : []);
+  if (names.length === 0) return t("automations.wait.chip.anyEvent");
+  const shown = names.slice(0, WAIT_CHIP_SOURCES);
+  const rest = events.length - shown.length;
+  return t("automations.wait.chip.event", {
+    source: listWords(
+      t,
+      rest > 0 ? [...shown, t("automations.wait.chip.more", { count: rest })] : shown,
+      "conjunction"
+    )
+  });
+}
+function sessionAutomationWaitWords(t, session, { now, timeZone = viewerTimeZone() }) {
+  const summary = session.automationWait;
+  const events = summary ? summary.events ?? (summary.event ? [summary.event] : []) : [];
+  const kind = summary ? events.length > 0 ? "event" : "schedule" : sessionAutomationWait(session);
+  if (!kind) return null;
+  if (!summary) {
+    const label = sessionAutomationWaitLabel(t, kind);
+    return {
+      kind,
+      label,
+      short: kind === "event" ? t("automations.wait.chip.anyEvent") : label
+    };
+  }
+  const event = events.length > 0 ? listWords(
+    t,
+    events.map((entry) => waitEventWords(t, entry)),
+    "disjunction"
+  ) : null;
+  const time = summary.nextRunAt ? formatRunTime(new Date(summary.nextRunAt), { timeZone, now, text: t }) : null;
+  const wait = event && time ? t("automations.wait.eventOrNextRun", { event, time }) : event ? t("automations.wait.eventFrom", { event }) : time ? t("automations.wait.nextRun", { time }) : sessionAutomationWaitLabel(t, kind);
+  const more = summary.events ? 0 : summary.automations - 1;
+  return {
+    kind,
+    label: more > 0 ? t("automations.wait.more", { wait, count: more }) : wait,
+    short: kind === "event" ? waitSourcesShort(t, events) : time ? t("automations.wait.chip.nextRun", { time }) : sessionAutomationWaitLabel(t, kind)
+  };
+}
+function sessionAutomationWaitLines(t, session, { now, timeZone = viewerTimeZone() }) {
+  const summary = session.automationWait;
+  if (!summary) {
+    const kind = sessionAutomationWait(session);
+    return [
+      kind ? { kind, text: sessionAutomationWaitLabel(t, kind) } : { kind: "none", text: t("automations.wait.none") }
+    ];
+  }
+  const events = summary.events ?? (summary.event ? [summary.event] : []);
+  const lines = events.map((event) => ({
+    kind: "event",
+    text: waitEventWords(t, event)
+  }));
+  if (summary.nextRunAt) {
+    lines.push({
+      kind: "schedule",
+      text: t("automations.wait.nextRun", {
+        time: formatRunTime(new Date(summary.nextRunAt), { timeZone, now, text: t })
+      })
+    });
+  }
+  const more = summary.events ? 0 : summary.automations - 1;
+  if (more > 0) {
+    lines.push({ kind: "event", text: t("automations.wait.details.more", { count: more }) });
+  }
+  if (lines.length === 0) {
+    lines.push({ kind: "schedule", text: sessionAutomationWaitLabel(t, "schedule") });
+  }
+  return lines;
+}
+
+export {
+  DEFAULT_EVENT_RUNS_PER_HOUR,
+  EVENT_TRIGGER_CONDITIONS_MAX,
+  EVENT_TRIGGER_TYPES_MAX,
+  EVENT_TRIGGERS_PER_AUTOMATION_MAX,
+  MAX_EVENT_RUNS_PER_HOUR,
+  emptyEventTriggersDraft,
+  newEventTriggerDraft,
+  newEventConditionDraft,
+  eventConditionDraftFrom,
+  eventTriggerDraftFrom,
+  eventTriggersDraftFrom,
+  EVENT_CONDITION_OPERATORS,
+  eventConditionOperator,
+  eventConditionOperatorLabel,
+  eventCommonFields,
+  eventConditionFromDraft,
+  eventTriggersInputFrom,
+  sameEventTriggers,
+  eventTypeIssue,
+  validateEventTriggers,
+  hasEventTriggerIssues,
+  eventTypeLabel,
+  eventTypesLabel,
+  eventConditionsLabel,
+  eventTriggerWords,
+  eventTriggersShortLabel,
+  eventTypeDescriptor,
+  eventConditionFieldSuggestions,
+  viewerTimeZone,
+  defaultAutomationCadence,
+  automationCadence,
+  automationScheduleSpec,
+  automationCadenceWords,
+  automationScheduleWords,
+  automationCadenceIssue,
+  automationCadenceRepeats,
+  hasEventTriggers,
+  isFinishedOnce,
+  automationNextRun,
+  automationListensForEvents,
+  isAgentAutomation,
+  sortAutomations,
+  automationWhenWords,
+  automationWhenSentence,
+  automationRunEventsLabel,
+  automationRunStatusLabel,
+  automationRunTriggerLabel,
+  automationRunErrorText,
+  AUTOMATION_NAME_MAX_LENGTH,
+  deriveAutomationName,
+  newAutomationDraft,
+  automationDraftFrom,
+  automationName,
+  validateAutomationDraft,
+  hasAutomationDraftIssues,
+  automationCreateRequest,
+  automationUpdateRequest,
+  sessionAutomationWaitWords,
+  sessionAutomationWaitLines
+};
+//# sourceMappingURL=chunk-2OP6WLGV.js.map