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.
/**
* Coworker tables: bots, skills, routines, bot-to-bot handoff.
*
* Split by owner so two people can add tables all day without touching the same lines. Add tables
* here; never edit core.ts or computer.ts to do it.
*/
import {
boolean,
index,
pgEnum,
pgTable,
primaryKey,
text,
timestamp,
} from "drizzle-orm/pg-core";
import { agents, users } from "./core";
import { jsonb } from "./json";
const createdAt = () =>
timestamp("created_at", { withTimezone: true }).notNull().defaultNow();
const updatedAt = () =>
timestamp("updated_at", { withTimezone: true }).notNull().defaultNow();
export const agentVisibility = pgEnum("agent_visibility", [
"public",
"private",
]);
export const agentProfiles = pgTable(
"agent_profiles",
{
agentId: text("agent_id")
.primaryKey()
.references(() => agents.id, { onDelete: "cascade" }),
ownerUserId: text("owner_user_id").references(() => users.id, {
onDelete: "set null",
}),
title: text("title").notNull(),
roleDescription: text("role_description").notNull(),
avatarSeed: text("avatar_seed").notNull(),
visibility: agentVisibility("visibility").notNull(),
/*
* A computer of its own rather than its owner's.
*
* By default every Bot a person uses runs on that person's one computer, each Bot with its own
* browser profile and folder there. An isolated Bot gets a computer keyed by the Bot instead, which
* keeps its logins between runs and which everyone who uses the Bot shares. Only someone the
* `isolatedComputers` capability allows may set it; when that is withdrawn the Bot runs on the
* person's computer again rather than stopping.
*/
isolated: boolean("isolated").notNull().default(false),
/*
* The credential this Bot's agent presents when it calls a tool back.
*
* A hash, never the token. We issue it, the agent's owner holds it, and this side only ever needs
* to check one: storing the token itself would mean a database dump is a set of working
* credentials for every registered agent.
*
* Null means the agent has not been issued one and may not call tools back, which is the right
* default: a URL somebody pasted gets no capability until an administrator hands it one.
*/
callbackTokenHash: text("callback_token_hash"),
callbackTokenIssuedAt: timestamp("callback_token_issued_at", {
withTimezone: true,
}),
deletedAt: timestamp("deleted_at", { withTimezone: true }),
createdAt: createdAt(),
updatedAt: updatedAt(),
},
(table) => [
index("agent_profiles_visibility_deleted_idx").on(
table.visibility,
table.deletedAt,
),
],
);
export const agentPreferences = pgTable(
"agent_preferences",
{
userId: text("user_id")
.notNull()
.references(() => users.id, { onDelete: "cascade" }),
agentId: text("agent_id")
.notNull()
.references(() => agents.id, { onDelete: "cascade" }),
hiddenAt: timestamp("hidden_at", { withTimezone: true }),
pinnedAt: timestamp("pinned_at", { withTimezone: true }),
},
(table) => [primaryKey({ columns: [table.userId, table.agentId] })],
);
export const routineRunStatus = pgEnum("routine_run_status", [
"succeeded",
"failed",
"skipped",
"waiting",
]);
/**
* A standing instruction one person gave one Bot, on a schedule.
*
* Owned rows all the way down: the owner is who the headless turn runs as, so the routine can do
* exactly what its owner could do in chat and nothing more. The channel is where the reply lands.
*/
export const routines = pgTable(
"routines",
{
id: text("id").primaryKey(),
ownerUserId: text("owner_user_id")
.notNull()
.references(() => users.id, { onDelete: "cascade" }),
agentId: text("agent_id")
.notNull()
.references(() => agents.id, { onDelete: "cascade" }),
/**
* Not a foreign key. Channels soft-delete (`channels.deletedAt`), and a routine pointing at a
* deleted channel must survive to be shown as broken rather than vanish in a cascade.
*/
channelId: text("channel_id").notNull(),
instruction: text("instruction").notNull(),
/** Five-field cron. Validated at the tool boundary; never parsed by the client. */
cron: text("cron").notNull(),
/** IANA zone the cron is read in. UTC when the person never said otherwise. */
timezone: text("timezone").notNull().default("UTC"),
enabled: boolean("enabled").notNull().default(true),
/** The sweep's read target. Recomputed on every write and CAS-advanced by the sweep. */
nextRunAt: timestamp("next_run_at", { withTimezone: true }).notNull(),
/**
* The last occurrence stamp the sweep advanced past — fired OR silently drained as stale.
* Not "when this last ran": the run history lives in routine_runs, and everything a person
* sees reads that table. This is the scheduler's own bookmark, kept because a CAS needs the
* value it compared against recorded somewhere a human can inspect when a clock looks wrong.
*/
lastRunAt: timestamp("last_run_at", { withTimezone: true }),
/**
* When this routine was last switched on, or created. The fatigue rule counts failures from
* here, so a routine switched off after ten failures and switched back on gets ten more chances
* rather than one. Not `updatedAt`, which every sweep that claims the routine moves.
*/
enabledAt: timestamp("enabled_at", { withTimezone: true })
.notNull()
.defaultNow(),
createdAt: createdAt(),
updatedAt: updatedAt(),
},
(table) => [
index("routines_due_idx").on(table.enabled, table.nextRunAt),
/** Owner-scoped reads and writes: listFor, countEnabled, and the users cascade all hit this. */
index("routines_by_owner_idx").on(table.ownerUserId, table.enabled),
],
);
export const routineSweeps = pgTable("routine_sweeps", {
id: text("id").primaryKey(),
sweptAt: timestamp("swept_at", { withTimezone: true }).notNull().defaultNow(),
owner: text("owner"),
});
/** One row per firing, which is what the page's "last ran" and the fatigue rule read. */
export const routineRuns = pgTable(
"routine_runs",
{
id: text("id").primaryKey(),
routineId: text("routine_id")
.notNull()
.references(() => routines.id, { onDelete: "cascade" }),
startedAt: timestamp("started_at", { withTimezone: true })
.notNull()
.defaultNow(),
finishedAt: timestamp("finished_at", { withTimezone: true }),
/** Null means the firing is still in flight; only a finished run has succeeded/failed/skipped. */
status: routineRunStatus("status"),
waiting: jsonb("waiting").$type<Record<string, unknown>>(),
/** The refusal or the throw, capped like audit payloads. Never shown raw to a person. */
error: text("error"),
/** What started this run: its schedule, a person pressing Run now, or an event trigger. */
source: text("source")
.$type<"schedule" | "run_now" | "trigger">()
.notNull()
.default("schedule"),
},
(table) => [
index("routine_runs_by_routine_idx").on(table.routineId, table.startedAt),
],
);