@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/lifeops/service-mixin-workflows.js

@@ -0,0 +1,710 @@
+import { computeNextCronRunAtMs } from "@elizaos/agent";
+import { LIFEOPS_WORKFLOW_STATUSES } from "../contracts/index.js";
+import {
+  getWorkflowStepRegistry,
+  UnknownWorkflowStepError
+} from "./registries/workflow-step-registry.js";
+import { resolveNextRelativeScheduleInstant } from "./relative-schedule-resolver.js";
+import {
+  createLifeOpsWorkflowDefinition,
+  createLifeOpsWorkflowRun
+} from "./repository.js";
+import { parseWorkflowSchedulerState } from "./service-helpers-browser.js";
+import {
+  isRecord,
+  normalizeOptionalRecord,
+  requireRecord
+} from "./service-helpers-misc.js";
+import {
+  fail,
+  normalizeEnumValue,
+  normalizeIsoString,
+  normalizeOptionalBoolean,
+  requireNonEmptyString
+} from "./service-normalize.js";
+import {
+  normalizeWorkflowPermissionPolicy,
+  normalizeWorkflowSchedule,
+  normalizeWorkflowTriggerType
+} from "./service-normalize-connector.js";
+import { normalizeWorkflowActionPlan } from "./service-normalize-task.js";
+import { LifeOpsServiceError } from "./service-types.js";
+import { addMinutes } from "./time.js";
+function matchesCalendarEventEndedFilters(event, filters) {
+  if (!filters) return true;
+  if (filters.calendarIds && filters.calendarIds.length > 0 && !filters.calendarIds.includes(event.calendarId)) {
+    return false;
+  }
+  if (filters.titleIncludesAny && filters.titleIncludesAny.length > 0) {
+    const title = event.title.toLowerCase();
+    if (!filters.titleIncludesAny.some(
+      (needle) => title.includes(needle.toLowerCase())
+    )) {
+      return false;
+    }
+  }
+  if (typeof filters.minDurationMinutes === "number") {
+    const durationMinutes = (Date.parse(event.endAt) - Date.parse(event.startAt)) / 6e4;
+    if (!Number.isFinite(durationMinutes) || durationMinutes < filters.minDurationMinutes) {
+      return false;
+    }
+  }
+  if (filters.attendeeEmailIncludesAny && filters.attendeeEmailIncludesAny.length > 0) {
+    const attendees = Array.isArray(event.attendees) ? event.attendees : [];
+    const emails = attendees.map(
+      (attendee) => attendee && typeof attendee === "object" && "email" in attendee ? String(attendee.email ?? "").toLowerCase() : ""
+    ).filter(Boolean);
+    if (!filters.attendeeEmailIncludesAny.some(
+      (needle) => emails.some((email) => email.includes(needle.toLowerCase()))
+    )) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchesLifeOpsDerivedEventFilters(event, filters, nowIso) {
+  if (!filters || typeof filters !== "object" || Array.isArray(filters)) {
+    return true;
+  }
+  const record = filters;
+  if (typeof record.minConfidence === "number" && event.confidence < record.minConfidence) {
+    return false;
+  }
+  if (typeof record.offsetMinutes === "number") {
+    const dueAtMs = Date.parse(event.occurredAt) + record.offsetMinutes * 6e4;
+    if (Date.parse(nowIso) < dueAtMs) {
+      return false;
+    }
+  }
+  if (event.kind === "lifeops.bedtime.imminent" && typeof record.minutesBefore === "number") {
+    const payloadMinutes = event.payload.minutesUntilBedtimeTarget;
+    if (typeof payloadMinutes !== "number" || payloadMinutes > record.minutesBefore) {
+      return false;
+    }
+  }
+  if (event.kind === "lifeops.regularity.changed" && typeof record.becomes === "string") {
+    const payload = event.payload;
+    const regularity = typeof payload === "object" && payload !== null ? payload.regularityClass : void 0;
+    if (regularity !== record.becomes) {
+      return false;
+    }
+  }
+  if (event.kind === "gmail.message.received" || event.kind === "gmail.thread.needs_response") {
+    const payload = isRecord(event.payload) ? event.payload : {};
+    const grantId = typeof payload.grantId === "string" ? payload.grantId : "";
+    if (Array.isArray(record.grantIds) && record.grantIds.length > 0 && !record.grantIds.includes(grantId)) {
+      return false;
+    }
+    if (Array.isArray(record.fromIncludesAny) && record.fromIncludesAny.length > 0) {
+      const sender = `${String(payload.from ?? "")} ${String(payload.fromEmail ?? "")}`.toLowerCase();
+      if (!record.fromIncludesAny.some(
+        (needle) => sender.includes(String(needle).toLowerCase())
+      )) {
+        return false;
+      }
+    }
+    if (Array.isArray(record.subjectIncludesAny) && record.subjectIncludesAny.length > 0) {
+      const subject = String(payload.subject ?? "").toLowerCase();
+      if (!record.subjectIncludesAny.some(
+        (needle) => subject.includes(String(needle).toLowerCase())
+      )) {
+        return false;
+      }
+    }
+    if (Array.isArray(record.labelIds) && record.labelIds.length > 0) {
+      const labels = new Set(
+        Array.isArray(payload.labels) ? payload.labels.map((label) => String(label)) : []
+      );
+      if (!record.labelIds.some((labelId) => labels.has(String(labelId)))) {
+        return false;
+      }
+    }
+    if (typeof record.requiresReplyNeeded === "boolean" && Boolean(payload.likelyReplyNeeded) !== record.requiresReplyNeeded) {
+      return false;
+    }
+  }
+  return true;
+}
+function withWorkflows(Base) {
+  const WorkflowsBase = Base;
+  class LifeOpsWorkflowServiceMixin extends WorkflowsBase {
+    readWorkflowSchedulerState(workflow) {
+      return parseWorkflowSchedulerState(
+        isRecord(workflow.metadata) ? workflow.metadata.lifeopsScheduler : null
+      );
+    }
+    computeWorkflowNextDueAt(workflow, cursorIso) {
+      if (workflow.triggerType !== "schedule") {
+        return null;
+      }
+      const schedule = workflow.schedule;
+      if (schedule.kind === "manual" || schedule.kind === "event" || schedule.kind === "relative_to_wake" || schedule.kind === "relative_to_bedtime" || schedule.kind === "during_morning" || schedule.kind === "during_night") {
+        return null;
+      }
+      if (schedule.kind === "once") {
+        return cursorIso ? null : schedule.runAt;
+      }
+      if (schedule.kind === "interval") {
+        const baseIso = cursorIso ?? workflow.createdAt;
+        return addMinutes(
+          new Date(baseIso),
+          schedule.everyMinutes
+        ).toISOString();
+      }
+      const baseMs = cursorIso ? Date.parse(cursorIso) : Date.parse(workflow.createdAt) - 6e4;
+      const nextRunMs = computeNextCronRunAtMs(
+        schedule.cronExpression,
+        baseMs,
+        schedule.timezone
+      );
+      return nextRunMs === null ? null : new Date(nextRunMs).toISOString();
+    }
+    withWorkflowSchedulerState(workflow, state) {
+      const metadata = { ...workflow.metadata };
+      if (state) {
+        metadata.lifeopsScheduler = state;
+      } else {
+        delete metadata.lifeopsScheduler;
+      }
+      return {
+        ...workflow,
+        metadata,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    initializeWorkflowSchedulerState(workflow) {
+      const currentState = this.readWorkflowSchedulerState(workflow);
+      const targetState = this.buildInitialSchedulerState(workflow);
+      if (currentState === null && targetState === null || currentState && targetState && currentState.nextDueAt === targetState.nextDueAt && currentState.lastDueAt === targetState.lastDueAt && currentState.lastRunId === targetState.lastRunId && currentState.lastRunStatus === targetState.lastRunStatus && (currentState.lastFiredEventEndAt ?? null) === (targetState.lastFiredEventEndAt ?? null) && (currentState.lastFiredEventId ?? null) === (targetState.lastFiredEventId ?? null)) {
+        return workflow;
+      }
+      return this.withWorkflowSchedulerState(workflow, targetState);
+    }
+    buildInitialSchedulerState(workflow) {
+      if (workflow.triggerType === "manual") {
+        return null;
+      }
+      if (workflow.triggerType === "event") {
+        return {
+          managedBy: "task_worker",
+          nextDueAt: null,
+          lastDueAt: null,
+          lastRunId: null,
+          lastRunStatus: null,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastFiredEventEndAt: workflow.createdAt,
+          lastFiredEventId: null
+        };
+      }
+      if (workflow.schedule.kind === "manual") {
+        return null;
+      }
+      return {
+        managedBy: "task_worker",
+        nextDueAt: this.computeWorkflowNextDueAt(workflow),
+        lastDueAt: null,
+        lastRunId: null,
+        lastRunStatus: null,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    async runDueWorkflows(args) {
+      const nowMs = Date.parse(args.now);
+      const workflows = await this.repository.listWorkflows(this.agentId());
+      const runs = [];
+      for (const workflow of workflows) {
+        if (runs.length >= args.limit) {
+          break;
+        }
+        if (workflow.status !== "active" || workflow.triggerType !== "schedule" || workflow.schedule.kind === "manual") {
+          continue;
+        }
+        let nextWorkflow = workflow;
+        const existingSchedulerState = this.readWorkflowSchedulerState(nextWorkflow);
+        let schedulerState = existingSchedulerState ?? {
+          managedBy: "task_worker",
+          nextDueAt: this.computeWorkflowNextDueAt(nextWorkflow),
+          lastDueAt: null,
+          lastRunId: null,
+          lastRunStatus: null,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        let stateChanged = existingSchedulerState === null;
+        if (schedulerState.nextDueAt === null && (nextWorkflow.schedule.kind === "relative_to_wake" || nextWorkflow.schedule.kind === "relative_to_bedtime" || nextWorkflow.schedule.kind === "during_morning" || nextWorkflow.schedule.kind === "during_night")) {
+          const effectiveSchedule = await this.readEffectiveScheduleState({
+            timezone: nextWorkflow.schedule.timezone,
+            now: new Date(args.now)
+          });
+          schedulerState = {
+            ...schedulerState,
+            nextDueAt: resolveNextRelativeScheduleInstant({
+              schedule: nextWorkflow.schedule,
+              state: effectiveSchedule,
+              cursorIso: schedulerState.lastDueAt,
+              nowMs: Date.parse(args.now)
+            }),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          stateChanged = true;
+        }
+        while (runs.length < args.limit && schedulerState.nextDueAt && Date.parse(schedulerState.nextDueAt) <= nowMs) {
+          const dueAt = schedulerState.nextDueAt;
+          const { run, error } = await this.executeWorkflowDefinition(
+            nextWorkflow,
+            {
+              startedAt: dueAt,
+              confirmBrowserActions: false,
+              request: {
+                scheduledExecution: true
+              }
+            }
+          );
+          runs.push(run);
+          await this.emitWorkflowRunNudge(nextWorkflow, run);
+          const nextDueAt = nextWorkflow.schedule.kind === "relative_to_wake" || nextWorkflow.schedule.kind === "relative_to_bedtime" || nextWorkflow.schedule.kind === "during_morning" || nextWorkflow.schedule.kind === "during_night" ? resolveNextRelativeScheduleInstant({
+            schedule: nextWorkflow.schedule,
+            state: await this.readEffectiveScheduleState({
+              timezone: nextWorkflow.schedule.timezone,
+              now: new Date(args.now)
+            }),
+            cursorIso: dueAt,
+            nowMs: Date.parse(args.now)
+          }) : this.computeWorkflowNextDueAt(nextWorkflow, dueAt);
+          schedulerState = {
+            managedBy: "task_worker",
+            nextDueAt,
+            lastDueAt: dueAt,
+            lastRunId: run.id,
+            lastRunStatus: run.status,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          stateChanged = true;
+          if (error) {
+            this.logLifeOpsError("workflow_scheduled_execution", error, {
+              workflowId: nextWorkflow.id,
+              workflowRunId: run.id,
+              dueAt
+            });
+          }
+        }
+        if (stateChanged) {
+          nextWorkflow = this.withWorkflowSchedulerState(
+            nextWorkflow,
+            schedulerState
+          );
+          await this.repository.updateWorkflow(nextWorkflow);
+        }
+      }
+      return runs;
+    }
+    /**
+     * Fires event-triggered workflows for calendar events that have ended since
+     * the workflow's cursor. Uses a (end_at, id) tuple cursor per workflow so
+     * repeated invocations never re-fire for the same event.
+     */
+    async runDueEventWorkflows(args) {
+      const workflows = await this.repository.listWorkflows(this.agentId());
+      const runs = [];
+      for (const workflow of workflows) {
+        if (runs.length >= args.limit) {
+          break;
+        }
+        if (workflow.status !== "active" || workflow.triggerType !== "event" || workflow.schedule.kind !== "event") {
+          continue;
+        }
+        const eventSchedule = workflow.schedule;
+        let nextWorkflow = workflow;
+        const existingState = this.readWorkflowSchedulerState(nextWorkflow);
+        let schedulerState = existingState ?? {
+          managedBy: "task_worker",
+          nextDueAt: null,
+          lastDueAt: null,
+          lastRunId: null,
+          lastRunStatus: null,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastFiredEventEndAt: nextWorkflow.createdAt,
+          lastFiredEventId: null
+        };
+        let stateChanged = existingState === null;
+        const remaining = args.limit - runs.length;
+        if (eventSchedule.eventKind === "calendar.event.ended") {
+          const candidates = await this.repository.listCalendarEventsEndedAfterCursor({
+            agentId: this.agentId(),
+            provider: "google",
+            side: "owner",
+            cursorEndAt: schedulerState.lastFiredEventEndAt ?? null,
+            cursorEventId: schedulerState.lastFiredEventId ?? null,
+            upToIso: args.now,
+            limit: Math.max(remaining * 4, 8)
+          });
+          const filters = eventSchedule.filters?.kind === "calendar.event.ended" ? eventSchedule.filters.filters : void 0;
+          for (const event of candidates) {
+            if (runs.length >= args.limit) {
+              break;
+            }
+            if (!matchesCalendarEventEndedFilters(event, filters)) {
+              schedulerState = {
+                ...schedulerState,
+                lastFiredEventEndAt: event.endAt,
+                lastFiredEventId: event.id,
+                updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+              };
+              stateChanged = true;
+              continue;
+            }
+            const { run, error } = await this.executeWorkflowDefinition(
+              nextWorkflow,
+              {
+                startedAt: event.endAt,
+                confirmBrowserActions: false,
+                request: {
+                  scheduledExecution: false,
+                  event: {
+                    kind: "calendar.event.ended",
+                    eventId: event.id,
+                    calendarId: event.calendarId,
+                    title: event.title,
+                    startAt: event.startAt,
+                    endAt: event.endAt,
+                    htmlLink: event.htmlLink
+                  }
+                }
+              }
+            );
+            runs.push(run);
+            await this.emitWorkflowRunNudge(nextWorkflow, run);
+            schedulerState = {
+              ...schedulerState,
+              lastDueAt: event.endAt,
+              lastRunId: run.id,
+              lastRunStatus: run.status,
+              lastFiredEventEndAt: event.endAt,
+              lastFiredEventId: event.id,
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            stateChanged = true;
+            if (error) {
+              this.logLifeOpsError("workflow_event_execution", error, {
+                workflowId: nextWorkflow.id,
+                workflowRunId: run.id,
+                eventId: event.id,
+                eventEndAt: event.endAt
+              });
+            }
+          }
+        } else {
+          const candidates = (args.lifeOpsEvents ?? []).filter((event) => event.kind === eventSchedule.eventKind).filter((event) => {
+            if (!schedulerState.lastFiredEventEndAt) {
+              return true;
+            }
+            if (event.occurredAt > schedulerState.lastFiredEventEndAt) {
+              return true;
+            }
+            return event.occurredAt === schedulerState.lastFiredEventEndAt && event.id !== schedulerState.lastFiredEventId;
+          }).slice(0, Math.max(remaining * 4, 8));
+          const filters = eventSchedule.filters?.kind === eventSchedule.eventKind ? eventSchedule.filters.filters : void 0;
+          for (const event of candidates) {
+            if (runs.length >= args.limit) {
+              break;
+            }
+            if (!matchesLifeOpsDerivedEventFilters(event, filters, args.now)) {
+              schedulerState = {
+                ...schedulerState,
+                updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+              };
+              stateChanged = true;
+              continue;
+            }
+            const { run, error } = await this.executeWorkflowDefinition(
+              nextWorkflow,
+              {
+                startedAt: event.occurredAt,
+                confirmBrowserActions: false,
+                request: {
+                  scheduledExecution: false,
+                  event: {
+                    kind: event.kind,
+                    eventId: event.id,
+                    occurredAt: event.occurredAt,
+                    confidence: event.confidence,
+                    payload: event.payload
+                  }
+                }
+              }
+            );
+            runs.push(run);
+            await this.emitWorkflowRunNudge(nextWorkflow, run);
+            schedulerState = {
+              ...schedulerState,
+              lastDueAt: event.occurredAt,
+              lastRunId: run.id,
+              lastRunStatus: run.status,
+              lastFiredEventEndAt: event.occurredAt,
+              lastFiredEventId: event.id,
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            stateChanged = true;
+            if (error) {
+              this.logLifeOpsError("workflow_event_execution", error, {
+                workflowId: nextWorkflow.id,
+                workflowRunId: run.id,
+                eventId: event.id,
+                eventEndAt: event.occurredAt
+              });
+            }
+          }
+        }
+        if (stateChanged) {
+          nextWorkflow = this.withWorkflowSchedulerState(
+            nextWorkflow,
+            schedulerState
+          );
+          await this.repository.updateWorkflow(nextWorkflow);
+        }
+      }
+      return runs;
+    }
+    async listWorkflows() {
+      const workflows = await this.repository.listWorkflows(this.agentId());
+      const records = [];
+      for (const definition of workflows) {
+        records.push({
+          definition,
+          runs: await this.repository.listWorkflowRuns(
+            this.agentId(),
+            definition.id
+          )
+        });
+      }
+      return records;
+    }
+    async getWorkflow(workflowId) {
+      const definition = await this.getWorkflowDefinition(workflowId);
+      return {
+        definition,
+        runs: await this.repository.listWorkflowRuns(
+          this.agentId(),
+          workflowId
+        )
+      };
+    }
+    async createWorkflow(request) {
+      const triggerType = normalizeWorkflowTriggerType(request.triggerType);
+      const ownership = this.normalizeOwnership(request.ownership);
+      let definition = createLifeOpsWorkflowDefinition({
+        agentId: this.agentId(),
+        ...ownership,
+        title: requireNonEmptyString(request.title, "title"),
+        triggerType,
+        schedule: normalizeWorkflowSchedule(request.schedule, triggerType),
+        actionPlan: normalizeWorkflowActionPlan(request.actionPlan),
+        permissionPolicy: normalizeWorkflowPermissionPolicy(
+          request.permissionPolicy
+        ),
+        status: request.status === void 0 ? "active" : normalizeEnumValue(
+          request.status,
+          "status",
+          LIFEOPS_WORKFLOW_STATUSES
+        ),
+        createdBy: request.createdBy === void 0 ? "user" : normalizeEnumValue(request.createdBy, "createdBy", [
+          "agent",
+          "user",
+          "workflow",
+          "connector"
+        ]),
+        metadata: normalizeOptionalRecord(request.metadata, "metadata") ?? {}
+      });
+      definition = this.initializeWorkflowSchedulerState(definition);
+      await this.repository.createWorkflow(definition);
+      await this.recordWorkflowAudit(
+        "workflow_created",
+        definition.id,
+        "user",
+        "workflow created",
+        { request },
+        {
+          triggerType: definition.triggerType,
+          status: definition.status
+        }
+      );
+      return {
+        definition,
+        runs: []
+      };
+    }
+    async updateWorkflow(workflowId, request) {
+      const current = await this.getWorkflowDefinition(workflowId);
+      const ownership = this.normalizeOwnership(request.ownership, current);
+      const nextTriggerType = request.triggerType === void 0 ? current.triggerType : normalizeWorkflowTriggerType(request.triggerType);
+      let nextDefinition = {
+        ...current,
+        ...ownership,
+        title: request.title === void 0 ? current.title : requireNonEmptyString(request.title, "title"),
+        triggerType: nextTriggerType,
+        schedule: request.schedule === void 0 ? current.schedule : normalizeWorkflowSchedule(request.schedule, nextTriggerType),
+        actionPlan: request.actionPlan === void 0 ? current.actionPlan : normalizeWorkflowActionPlan(request.actionPlan),
+        permissionPolicy: normalizeWorkflowPermissionPolicy(
+          request.permissionPolicy,
+          current.permissionPolicy
+        ),
+        status: request.status === void 0 ? current.status : normalizeEnumValue(
+          request.status,
+          "status",
+          LIFEOPS_WORKFLOW_STATUSES
+        ),
+        metadata: request.metadata === void 0 ? current.metadata : {
+          ...current.metadata,
+          ...requireRecord(request.metadata, "metadata")
+        },
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (request.triggerType !== void 0 || request.schedule !== void 0 || this.readWorkflowSchedulerState(nextDefinition) === null) {
+        nextDefinition = this.initializeWorkflowSchedulerState(nextDefinition);
+      }
+      await this.repository.updateWorkflow(nextDefinition);
+      await this.recordWorkflowAudit(
+        "workflow_updated",
+        nextDefinition.id,
+        "user",
+        "workflow updated",
+        { request },
+        {
+          triggerType: nextDefinition.triggerType,
+          status: nextDefinition.status
+        }
+      );
+      return this.getWorkflow(nextDefinition.id);
+    }
+    async executeWorkflowDefinition(definition, args) {
+      const outputs = {};
+      const steps = [];
+      let status = "success";
+      const registry = getWorkflowStepRegistry(this.runtime);
+      if (!registry) {
+        throw new Error(
+          "WorkflowStepRegistry not registered on runtime \u2014 call registerDefaultWorkflowStepPack() in plugin init"
+        );
+      }
+      const ctx = this;
+      try {
+        for (const [index, step] of definition.actionPlan.steps.entries()) {
+          const contribution = registry.get(step.kind);
+          if (!contribution) {
+            throw new UnknownWorkflowStepError(
+              step.kind,
+              registry.list().map((c) => c.kind)
+            );
+          }
+          const validated = contribution.paramSchema.parse(step);
+          const stepArgs = {
+            definition,
+            startedAt: args.startedAt,
+            confirmBrowserActions: args.confirmBrowserActions,
+            request: args.request,
+            outputs,
+            previousStepValue: steps.at(-1)?.value ?? null
+          };
+          const value = await contribution.execute(validated, stepArgs, ctx);
+          const stepRecord = {
+            index,
+            kind: step.kind,
+            resultKey: step.resultKey ?? null,
+            value
+          };
+          if (step.resultKey) {
+            outputs[step.resultKey] = value;
+          }
+          steps.push(stepRecord);
+        }
+      } catch (error) {
+        status = "failed";
+        steps.push({
+          error: error instanceof Error ? error.message : String(error)
+        });
+        const audit2 = await this.recordWorkflowAudit(
+          "workflow_run",
+          definition.id,
+          "workflow",
+          "workflow run failed",
+          {
+            request: args.request
+          },
+          {
+            status,
+            steps
+          }
+        );
+        const run2 = createLifeOpsWorkflowRun({
+          agentId: this.agentId(),
+          workflowId: definition.id,
+          startedAt: args.startedAt,
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          status,
+          result: { steps, outputs },
+          auditRef: audit2.id
+        });
+        await this.repository.createWorkflowRun(run2);
+        return {
+          run: run2,
+          error
+        };
+      }
+      const audit = await this.recordWorkflowAudit(
+        "workflow_run",
+        definition.id,
+        "workflow",
+        "workflow run succeeded",
+        {
+          request: args.request
+        },
+        {
+          status,
+          steps
+        }
+      );
+      const run = createLifeOpsWorkflowRun({
+        agentId: this.agentId(),
+        workflowId: definition.id,
+        startedAt: args.startedAt,
+        finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status,
+        result: { steps, outputs },
+        auditRef: audit.id
+      });
+      await this.repository.createWorkflowRun(run);
+      return {
+        run,
+        error: null
+      };
+    }
+    async runWorkflow(workflowId, request = {}) {
+      const definition = await this.getWorkflowDefinition(workflowId);
+      if (definition.status !== "active") {
+        fail(409, `workflow cannot run from status ${definition.status}`);
+      }
+      const startedAt = request.now === void 0 ? (/* @__PURE__ */ new Date()).toISOString() : normalizeIsoString(request.now, "now");
+      const confirmBrowserActions = normalizeOptionalBoolean(
+        request.confirmBrowserActions,
+        "confirmBrowserActions"
+      ) ?? false;
+      const result = await this.executeWorkflowDefinition(definition, {
+        startedAt,
+        confirmBrowserActions,
+        request
+      });
+      if (result.error instanceof LifeOpsServiceError) {
+        throw result.error;
+      }
+      if (result.error) {
+        throw result.error;
+      }
+      return result.run;
+    }
+  }
+  return LifeOpsWorkflowServiceMixin;
+}
+export {
+  matchesCalendarEventEndedFilters,
+  withWorkflows
+};
+//# sourceMappingURL=service-mixin-workflows.js.map