Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

17.0 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { and, desc, eq } from "drizzle-orm";
import type { Database } from "../db/client";
import {
  responsibilities,
  responsibilityEvents,
  responsibilityRuns,
  responsibilityTriggers,
} from "../db/schema/responsibilities";
import { workItems } from "../db/schema/work";
import { RESPONSIBILITY_RUN_KIND } from "./engine";
import {
  parseResponsibilityEvent,
  parseResponsibilityInput,
  parseResponsibilityPatch,
  type Responsibility,
  ResponsibilityNotFoundError,
  ResponsibilityRefusedError,
  type ResponsibilityStore,
} from "./types";

type Transaction = Parameters<Parameters<Database["transaction"]>[0]>[0];
type Connection = Database | Transaction;
export type ResponsibilityTargetResolver = (
  ownerUserId: string,
  agentId: string,
  channelId: string,
) => Promise<{ threadId: string } | null>;

export function createResponsibilityStore(
  database: Database,
  options: { resolveTarget: ResponsibilityTargetResolver },
): ResponsibilityStore {
  async function owned(
    connection: Connection,
    ownerUserId: string,
    id: string,
    lock = false,
  ): Promise<Responsibility> {
    const query = connection
      .select()
      .from(responsibilities)
      .where(
        and(
          eq(responsibilities.id, id),
          eq(responsibilities.ownerUserId, ownerUserId),
        ),
      );
    const [row] = await (lock ? query.for("update") : query);
    if (!row) throw new ResponsibilityNotFoundError();
    return row;
  }
  async function queueRun(
    transaction: Transaction,
    runId: string,
    key = runId,
  ) {
    await transaction
      .insert(workItems)
      .values({ kind: RESPONSIBILITY_RUN_KIND, key, payload: { runId } })
      .onConflictDoNothing();
  }
  const store: ResponsibilityStore = {
    async create(ownerUserId, input) {
      const value = parseResponsibilityInput(input);
      const target = await options.resolveTarget(
        ownerUserId,
        value.agentId,
        value.channelId,
      );
      if (!target)
        throw new ResponsibilityRefusedError(
          "Choose an accessible Bot and conversation you belong to.",
        );
      const [row] = await database
        .insert(responsibilities)
        .values({
          id: randomUUID(),
          ownerUserId,
          threadId: target.threadId,
          ...value,
        })
        .returning();
      if (!row) throw new Error("Responsibility creation returned no row.");
      return row;
    },
    list: (ownerUserId) =>
      database
        .select()
        .from(responsibilities)
        .where(eq(responsibilities.ownerUserId, ownerUserId))
        .orderBy(desc(responsibilities.updatedAt))
        .limit(100),
    get: (ownerUserId, id) => owned(database, ownerUserId, id),
    async update(ownerUserId, id, input) {
      const patch = parseResponsibilityPatch(input);
      return database.transaction(async (transaction) => {
        await owned(transaction, ownerUserId, id, true);
        const [row] = await transaction
          .update(responsibilities)
          .set({ ...patch, updatedAt: new Date() })
          .where(eq(responsibilities.id, id))
          .returning();
        if (!row) throw new ResponsibilityNotFoundError();
        return row;
      });
    },
    async transition(ownerUserId, id, status) {
      if (!["active", "paused", "completed"].includes(status))
        throw new ResponsibilityRefusedError(
          "Choose active, paused or completed.",
        );
      return database.transaction(async (transaction) => {
        const existing = await owned(transaction, ownerUserId, id, true);
        if (existing.status === "completed" && status !== "completed")
          throw new ResponsibilityRefusedError(
            "A completed responsibility cannot be resumed. Create a new responsibility.",
          );
        const [row] = await transaction
          .update(responsibilities)
          .set({
            status,
            completedAt:
              status === "completed"
                ? (existing.completedAt ?? new Date())
                : null,
            updatedAt: new Date(),
          })
          .where(eq(responsibilities.id, id))
          .returning();
        if (!row) throw new ResponsibilityNotFoundError();
        return row;
      });
    },
    async recordProgress(ownerUserId, id, input, agentId) {
      const summary = input.summary.trim();
      if (!summary || summary.length > 6000)
        throw new ResponsibilityRefusedError(
          "Progress must contain 1–6000 characters.",
        );
      return database.transaction(async (transaction) => {
        const existing = await owned(transaction, ownerUserId, id, true);
        if (agentId && existing.agentId !== agentId)
          throw new ResponsibilityNotFoundError();
        if (existing.status !== "active")
          throw new ResponsibilityRefusedError(
            "Only an active responsibility can make progress.",
          );
        if (input.sourceRunId) {
          const [run] = await transaction
            .select()
            .from(responsibilityRuns)
            .where(
              and(
                eq(responsibilityRuns.id, input.sourceRunId),
                eq(responsibilityRuns.responsibilityId, id),
                eq(responsibilityRuns.status, "running"),
              ),
            );
          if (!run)
            throw new ResponsibilityRefusedError(
              "Progress must come from the responsibility's current run.",
            );
        }
        const [row] = await transaction
          .update(responsibilities)
          .set({
            progress: summary,
            ...(input.complete
              ? { status: "completed" as const, completedAt: new Date() }
              : {}),
            updatedAt: new Date(),
          })
          .where(eq(responsibilities.id, id))
          .returning();
        if (!row) throw new ResponsibilityNotFoundError();
        return row;
      });
    },
    async listRuns(ownerUserId, id) {
      await owned(database, ownerUserId, id);
      return database
        .select()
        .from(responsibilityRuns)
        .where(eq(responsibilityRuns.responsibilityId, id))
        .orderBy(desc(responsibilityRuns.createdAt))
        .limit(50);
    },
    async ingestEvent(input) {
      const event = parseResponsibilityEvent(input);
      return database.transaction(async (transaction) => {
        if (event.responsibilityId)
          await owned(transaction, event.ownerUserId, event.responsibilityId);
        if (event.triggerId) {
          // The ingress resolved this trigger server-side; re-checked here so a caller of the store
          // cannot name a trigger that is not this owner's registration for this responsibility.
          const [trigger] = await transaction
            .select({ id: responsibilityTriggers.id })
            .from(responsibilityTriggers)
            .where(
              and(
                eq(responsibilityTriggers.id, event.triggerId),
                eq(responsibilityTriggers.ownerUserId, event.ownerUserId),
                eq(
                  responsibilityTriggers.responsibilityId,
                  event.responsibilityId ?? "",
                ),
              ),
            );
          if (!trigger) throw new ResponsibilityNotFoundError();
        }
        const eventId = randomUUID();
        const inserted = await transaction
          .insert(responsibilityEvents)
          .values({
            id: eventId,
            ownerUserId: event.ownerUserId,
            source: event.source,
            externalId: event.externalId,
            type: event.type,
            payload: event.payload,
          })
          .onConflictDoNothing({
            target: [
              responsibilityEvents.ownerUserId,
              responsibilityEvents.source,
              responsibilityEvents.externalId,
            ],
          })
          .returning({ id: responsibilityEvents.id });
        if (inserted.length === 0) {
          const [existing] = await transaction
            .select({ id: responsibilityEvents.id })
            .from(responsibilityEvents)
            .where(
              and(
                eq(responsibilityEvents.ownerUserId, event.ownerUserId),
                eq(responsibilityEvents.source, event.source),
                eq(responsibilityEvents.externalId, event.externalId),
              ),
            );
          if (!existing)
            throw new Error(
              "Duplicate responsibility event could not be loaded.",
            );
          const runs = await transaction
            .select({ id: responsibilityRuns.id })
            .from(responsibilityRuns)
            .where(eq(responsibilityRuns.eventId, existing.id));
          return {
            eventId: existing.id,
            duplicate: true,
            runIds: runs.map((run) => run.id),
          };
        }
        const candidates = await transaction
          .select()
          .from(responsibilities)
          .where(
            and(
              eq(responsibilities.ownerUserId, event.ownerUserId),
              eq(responsibilities.status, "active"),
              ...(event.responsibilityId
                ? [eq(responsibilities.id, event.responsibilityId)]
                : []),
            ),
          )
          .for("update");
        const matching = candidates.filter(
          (goal) =>
            (event.source === "manual" && event.responsibilityId === goal.id) ||
            (event.triggerId !== undefined &&
              event.responsibilityId === goal.id) ||
            goal.subscriptions.some(
              (subscription) =>
                subscription.source === event.source &&
                (subscription.eventType === event.type ||
                  subscription.eventType === "*"),
            ),
        );
        const runIds: string[] = [];
        for (const goal of matching) {
          const runId = randomUUID();
          await transaction
            .insert(responsibilityRuns)
            .values({ id: runId, responsibilityId: goal.id, eventId });
          await queueRun(transaction, runId);
          runIds.push(runId);
        }
        return { eventId, duplicate: false, runIds };
      });
    },
    async beginRun(runId, recovery) {
      // Resolve access before taking pooled transaction connections. The resolver reads the
      // actor/Bot/channel stores; running it inside two simultaneous transactions on a pool of
      // two would deadlock both while each waited for a third connection.
      const [reference] = await database
        .select({ responsibilityId: responsibilityRuns.responsibilityId })
        .from(responsibilityRuns)
        .where(eq(responsibilityRuns.id, runId));
      if (!reference) return null;
      const [targetGoal] = await database
        .select()
        .from(responsibilities)
        .where(eq(responsibilities.id, reference.responsibilityId));
      if (!targetGoal) return null;
      const target =
        targetGoal.status === "active"
          ? await options.resolveTarget(
              targetGoal.ownerUserId,
              targetGoal.agentId,
              targetGoal.channelId,
            )
          : null;
      return database.transaction(async (transaction) => {
        const [reference] = await transaction
          .select({ responsibilityId: responsibilityRuns.responsibilityId })
          .from(responsibilityRuns)
          .where(eq(responsibilityRuns.id, runId));
        if (!reference) return null;
        const [goal] = await transaction
          .select()
          .from(responsibilities)
          .where(eq(responsibilities.id, reference.responsibilityId))
          .for("update");
        if (!goal) return null;
        const [run] = await transaction
          .select()
          .from(responsibilityRuns)
          .where(eq(responsibilityRuns.id, runId))
          .for("update");
        if (!run) return null;
        if (run.status === "running" && recovery?.recovered) {
          await transaction
            .update(responsibilityRuns)
            .set({
              status: "failed",
              error:
                "The worker stopped during this run. Actions may already have executed; this run was not replayed.",
              finishedAt: new Date(),
            })
            .where(eq(responsibilityRuns.id, runId));
          return null;
        }
        if (run.status !== "queued") return null;
        if (
          goal.status !== "active" ||
          !target ||
          target.threadId !== goal.threadId
        ) {
          await transaction
            .update(responsibilityRuns)
            .set({
              status: "skipped",
              error:
                goal.status !== "active"
                  ? `Responsibility is ${goal.status}.`
                  : "Bot or conversation access changed.",
              finishedAt: new Date(),
            })
            .where(eq(responsibilityRuns.id, runId));
          return null;
        }
        const [event] = await transaction
          .select()
          .from(responsibilityEvents)
          .where(eq(responsibilityEvents.id, run.eventId));
        if (!event) throw new Error("Responsibility run has no event.");
        await transaction
          .update(responsibilityRuns)
          .set({ status: "running", startedAt: new Date(), finishedAt: null })
          .where(eq(responsibilityRuns.id, runId));
        return {
          runId,
          responsibilityId: goal.id,
          ownerUserId: goal.ownerUserId,
          agentId: goal.agentId,
          channelId: goal.channelId,
          threadId: goal.threadId,
          instruction: goal.instruction,
          successCriteria: goal.successCriteria,
          progress: goal.progress,
          eventId: run.eventId,
          event: {
            source: event.source,
            type: event.type,
            payload: event.payload,
          },
          continuation: run.continuation,
        };
      });
    },
    async settleRun(runId, outcome) {
      await database.transaction(async (transaction) => {
        const [reference] = await transaction
          .select({ responsibilityId: responsibilityRuns.responsibilityId })
          .from(responsibilityRuns)
          .where(eq(responsibilityRuns.id, runId));
        if (!reference) throw new ResponsibilityNotFoundError();
        await transaction
          .select({ id: responsibilities.id })
          .from(responsibilities)
          .where(eq(responsibilities.id, reference.responsibilityId))
          .for("update");
        const [run] = await transaction
          .select()
          .from(responsibilityRuns)
          .where(eq(responsibilityRuns.id, runId))
          .for("update");
        if (run?.status !== "running")
          throw new ResponsibilityRefusedError(
            "This responsibility run is no longer running.",
          );
        const replyText =
          outcome.status === "succeeded"
            ? outcome.replyText.slice(0, 32_000)
            : null;
        await transaction
          .update(responsibilityRuns)
          .set({
            status: outcome.status,
            replyText,
            error: "error" in outcome ? outcome.error : null,
            waiting: outcome.status === "waiting" ? outcome.waiting : null,
            continuation: null,
            finishedAt: outcome.status === "waiting" ? null : new Date(),
          })
          .where(eq(responsibilityRuns.id, runId));
        if (outcome.status === "succeeded")
          await transaction
            .update(responsibilities)
            .set({ lastResult: replyText, updatedAt: new Date() })
            .where(eq(responsibilities.id, run.responsibilityId));
      });
    },
    async resumeWaiting(ownerUserId, runId, response) {
      if (JSON.stringify(response)?.length > 32_768)
        throw new ResponsibilityRefusedError(
          "Continuation response exceeds 32 KiB.",
        );
      return database.transaction(async (transaction) => {
        const [reference] = await transaction
          .select({ responsibilityId: responsibilityRuns.responsibilityId })
          .from(responsibilityRuns)
          .where(eq(responsibilityRuns.id, runId));
        if (!reference) throw new ResponsibilityNotFoundError();
        const goal = await owned(
          transaction,
          ownerUserId,
          reference.responsibilityId,
          true,
        );
        const [run] = await transaction
          .select()
          .from(responsibilityRuns)
          .where(eq(responsibilityRuns.id, runId))
          .for("update");
        if (!run) throw new ResponsibilityNotFoundError();
        if (goal.status !== "active")
          throw new ResponsibilityRefusedError(
            "Resume the responsibility before answering its waiting run.",
          );
        if (run.status !== "waiting" || !run.waiting) return false;
        await transaction
          .update(responsibilityRuns)
          .set({
            status: "queued",
            continuation: { waiting: run.waiting, response },
            error: null,
          })
          .where(eq(responsibilityRuns.id, runId));
        await queueRun(transaction, runId, `${runId}:resume:${randomUUID()}`);
        return true;
      });
    },
  };
  return store;
}