Comp AI CRM is an open source, CRM designed for AI agents. Agentic-first CRM.
TypeScript
import { afterAll, afterEach, beforeAll, describe, expect, it } from "bun:test";
import { DEFAULT_WORKSPACE_NAME, WORKSPACE_ID } from "@crm/auth/organization";
import { db } from "@crm/db";
import { workspaceSlug } from "@crm/db/workspace";
import { AgentAccessService } from "../src/agent/agent-access.service";
import { AgentRunsService } from "../src/agent/agent-runs.service";
import { AgentTriggerService } from "../src/agent/agent-trigger.service";
const suffix = crypto.randomUUID();
const userId = `agent-run-user-${suffix}`;
const outsiderId = `agent-run-outsider-${suffix}`;
const memberId = `agent-run-member-${suffix}`;
let agentId = "";
let versionId = "";
let pokeCount = 0;
let cancelPokes: string[] = [];
const trigger = {
deployedAgentRunQueued() {
pokeCount += 1;
},
deployedAgentRunCancelled(runId: string) {
cancelPokes.push(runId);
},
} as AgentTriggerService;
const service = new AgentRunsService(db, new AgentAccessService(db), trigger);
beforeAll(async () => {
await db.organization.upsert({
where: { id: WORKSPACE_ID },
update: {},
create: {
id: WORKSPACE_ID,
name: DEFAULT_WORKSPACE_NAME,
slug: workspaceSlug(DEFAULT_WORKSPACE_NAME),
createdAt: new Date(),
},
});
await db.user.createMany({
data: [
{
id: userId,
name: "Agent Run Test",
email: `${userId}@example.test`,
},
{
id: outsiderId,
name: "Agent Run Outsider",
email: `${outsiderId}@example.test`,
},
],
});
await db.member.create({
data: {
id: memberId,
organizationId: WORKSPACE_ID,
userId,
role: "member",
createdAt: new Date(),
},
});
const agent = await db.agentDefinition.create({
data: { name: "Run safely", status: "LIVE", createdById: userId },
select: { id: true },
});
agentId = agent.id;
const version = await db.agentVersion.create({
data: {
agentId,
number: 1,
status: "DEPLOYED",
instructions: "Run once.",
manifest: {},
modelId: "test/model",
sandboxPolicy: {},
createdById: userId,
},
select: { id: true },
});
versionId = version.id;
await db.agentDefinition.update({
where: { id: agentId },
data: { currentVersionId: versionId },
});
});
afterAll(async () => {
const agentIds = (
await db.agentDefinition.findMany({
where: { createdById: userId },
select: { id: true },
})
).map((agent) => agent.id);
if (agentIds.length > 0) {
await db.agentRunEvent.deleteMany({
where: { run: { agentId: { in: agentIds } } },
});
await db.agentAction.deleteMany({
where: { agentId: { in: agentIds } },
});
await db.agentAuditEvent.deleteMany({
where: { agentId: { in: agentIds } },
});
await db.agentRun.deleteMany({
where: { agentId: { in: agentIds } },
});
await db.agentDefinition.updateMany({
where: { id: { in: agentIds } },
data: { currentVersionId: null },
});
await db.agentVersion.deleteMany({
where: { agentId: { in: agentIds } },
});
await db.agentDefinition.deleteMany({
where: { id: { in: agentIds } },
});
}
await db.member.deleteMany({ where: { id: memberId } });
await db.user.deleteMany({ where: { id: { in: [userId, outsiderId] } } });
});
afterEach(async () => {
if (!agentId) return;
await db.agentRun.updateMany({
where: {
agentId,
status: { in: ["QUEUED", "RUNNING", "WAITING_FOR_APPROVAL"] },
},
data: {
status: "CANCELLED",
errorCode: "TEST_CLEANUP",
errorMessage: "Settled between tests.",
finishedAt: new Date(),
},
});
});
describe("manual agent runs", () => {
it("returns ordered, transport-safe run and activity history", async () => {
const clientRequestId = crypto.randomUUID();
const { id: runId } = await service.runNow(
{ id: agentId, clientRequestId },
userId,
);
const startedAt = new Date("2026-08-05T12:00:00.000Z");
const completedAt = new Date("2026-08-05T12:00:02.000Z");
await db.agentRun.update({
where: { id: runId },
data: {
status: "SUCCEEDED",
summary: "Prepared the account brief",
modelId: "test/model",
inputTokens: 120,
outputTokens: 80,
costUsd: "0.012345",
startedAt,
finishedAt: completedAt,
},
});
await db.agentRunEvent.create({
data: {
runId,
sequence: 1,
type: "run.completed",
data: { summary: "Prepared the account brief" },
emittedAt: completedAt,
},
});
await db.agentAction.create({
data: {
agentId,
runId,
type: "timeline.note.created",
provider: "crm",
targetType: "company",
targetId: "company-1",
targetLabel: "Acme",
summary: "Added a meeting brief",
status: "SUCCEEDED",
idempotencyKey: `action-${clientRequestId}`,
plannedAt: startedAt,
startedAt,
completedAt,
},
});
const [runs, activity] = await Promise.all([
service.list(agentId, 1, userId),
service.activity(agentId, 1, userId),
]);
expect(runs).toHaveLength(1);
expect(runs[0]).toMatchObject({
id: runId,
status: "SUCCEEDED",
costUsd: "0.012345",
startedAt: startedAt.toISOString(),
finishedAt: completedAt.toISOString(),
events: [
{ sequence: 0, type: "run.queued", emittedAt: expect.any(String) },
{
sequence: 1,
type: "run.completed",
emittedAt: completedAt.toISOString(),
},
],
actions: [
{
type: "timeline.note.created",
plannedAt: startedAt.toISOString(),
startedAt: startedAt.toISOString(),
completedAt: completedAt.toISOString(),
},
],
});
expect(runs[0]?.createdAt).toBe(
new Date(runs[0]?.createdAt ?? "").toISOString(),
);
expect(activity).toHaveLength(1);
expect(activity[0]).toMatchObject({
type: "run.requested",
requestId: clientRequestId,
emittedAt: expect.any(String),
actorUser: { id: userId },
version: { id: versionId, number: 1 },
});
});
it("rejects a manual run while an agent is not live", async () => {
const beforePokeCount = pokeCount;
const draft = await db.agentDefinition.create({
data: {
name: "Draft run guard",
status: "DRAFT",
createdById: userId,
},
select: { id: true },
});
let runError: unknown;
try {
await service.runNow(
{ id: draft.id, clientRequestId: crypto.randomUUID() },
userId,
);
} catch (error) {
runError = error;
}
expect((runError as Error).message).toBe("This agent is not live yet.");
expect(pokeCount).toBe(beforePokeCount);
});
it("deduplicates concurrent requests and keeps the run and audit atomic", async () => {
const beforePokeCount = pokeCount;
const clientRequestId = crypto.randomUUID();
const results = await Promise.all(
Array.from({ length: 4 }, () =>
service.runNow({ id: agentId, clientRequestId }, userId),
),
);
expect(new Set(results.map((result) => result.id)).size).toBe(1);
expect(
await db.agentRun.count({ where: { idempotencyKey: clientRequestId } }),
).toBe(1);
expect(
await db.agentAuditEvent.count({
where: { agentId, type: "run.requested", requestId: clientRequestId },
}),
).toBe(1);
expect(pokeCount).toBe(beforePokeCount + 4);
});
it("rejects a second manual run while the first is active", async () => {
const first = await service.runNow(
{ id: agentId, clientRequestId: crypto.randomUUID() },
userId,
);
let error: Error | null = null;
try {
await service.runNow(
{ id: agentId, clientRequestId: crypto.randomUUID() },
userId,
);
} catch (caught) {
error = caught as Error;
}
expect(error?.message).toBe(
"This agent already has an active run. Stop it or wait for it to finish.",
);
expect(
await db.agentRun.count({
where: {
agentId,
status: { in: ["QUEUED", "RUNNING", "WAITING_FOR_APPROVAL"] },
},
}),
).toBe(1);
expect(
await db.agentRun.findUniqueOrThrow({ where: { id: first.id } }),
).toMatchObject({ status: "QUEUED" });
});
it("checks workspace membership before replaying an existing request", async () => {
const clientRequestId = crypto.randomUUID();
await service.runNow({ id: agentId, clientRequestId }, userId);
let error: Error | null = null;
try {
await service.runNow({ id: agentId, clientRequestId }, outsiderId);
} catch (caught) {
error = caught as Error;
}
expect(error?.message).toBe("You are not a member of this workspace.");
});
it("retries a failed run against the version that run executed", async () => {
const first = await service.runNow(
{ id: agentId, clientRequestId: crypto.randomUUID() },
userId,
);
await db.agentRun.update({
where: { id: first.id },
data: {
status: "FAILED",
errorCode: "TEST_FAILURE",
errorMessage: "Broke before the retry.",
finishedAt: new Date(),
},
});
const redeployed = await db.agentVersion.create({
data: {
agentId,
number: 2,
status: "DEPLOYED",
instructions: "Run differently.",
manifest: {},
modelId: "test/model",
sandboxPolicy: {},
createdById: userId,
},
select: { id: true },
});
await db.agentDefinition.update({
where: { id: agentId },
data: { currentVersionId: redeployed.id },
});
const clientRequestId = crypto.randomUUID();
try {
const retried = await service.retryRun(
{ id: agentId, runId: first.id, clientRequestId },
userId,
);
expect(
await db.agentRun.findUniqueOrThrow({
where: { id: retried.id },
select: { versionId: true },
}),
).toEqual({ versionId });
expect(
await db.agentAuditEvent.findFirstOrThrow({
where: { agentId, type: "run.requested", requestId: clientRequestId },
select: { versionId: true },
}),
).toEqual({ versionId });
} finally {
await db.agentDefinition.update({
where: { id: agentId },
data: { currentVersionId: versionId },
});
}
});
it("allows only one agent to claim a globally reused request id", async () => {
const otherAgent = await db.agentDefinition.create({
data: { name: "Other live agent", status: "LIVE", createdById: userId },
select: { id: true },
});
const otherVersion = await db.agentVersion.create({
data: {
agentId: otherAgent.id,
number: 1,
status: "DEPLOYED",
instructions: "Run once.",
manifest: {},
modelId: "test/model",
sandboxPolicy: {},
createdById: userId,
},
select: { id: true },
});
await db.agentDefinition.update({
where: { id: otherAgent.id },
data: { currentVersionId: otherVersion.id },
});
const clientRequestId = crypto.randomUUID();
const attempts = await Promise.allSettled([
service.runNow({ id: agentId, clientRequestId }, userId),
service.runNow({ id: otherAgent.id, clientRequestId }, userId),
]);
expect(
attempts.filter((attempt) => attempt.status === "fulfilled"),
).toHaveLength(1);
expect(
attempts.filter((attempt) => attempt.status === "rejected"),
).toHaveLength(1);
expect(
await db.agentRun.count({ where: { idempotencyKey: clientRequestId } }),
).toBe(1);
});
});
describe("cancelling a run", () => {
async function queuedRun() {
const { id } = await service.runNow(
{ id: agentId, clientRequestId: crypto.randomUUID() },
userId,
);
cancelPokes = [];
return id;
}
it("settles a queued run and asks the agent to drop the turn", async () => {
const runId = await queuedRun();
const result = await service.cancelRun({ id: agentId, runId }, userId);
expect(result).toMatchObject({ id: runId, status: "CANCELLED" });
expect(result.cancelled).toBe(true);
expect(cancelPokes).toEqual([runId]);
const run = await db.agentRun.findUniqueOrThrow({
where: { id: runId },
select: { status: true, errorCode: true, finishedAt: true },
});
expect(run.status).toBe("CANCELLED");
expect(run.errorCode).toBe("CANCELLED_BY_USER");
expect(run.finishedAt).not.toBeNull();
});
it("records one terminal event and one audit event", async () => {
const runId = await queuedRun();
await service.cancelRun({ id: agentId, runId }, userId);
const events = await db.agentRunEvent.findMany({
where: { runId, type: "run.cancelled" },
select: { id: true },
});
expect(events).toHaveLength(1);
expect(events[0]?.id).toBe(`run-terminal:${runId}:cancelled`);
expect(
await db.agentAuditEvent.count({
where: { agentId, type: "run.cancelled", requestId: runId },
}),
).toBe(1);
});
it("cancels outstanding actions so nothing is left running", async () => {
const runId = await queuedRun();
await db.agentAction.createMany({
data: [
{
agentId,
runId,
type: "crm.activity.create",
provider: "crm",
summary: "Planned note",
status: "PLANNED",
idempotencyKey: `${runId}:planned`,
requestHash: "planned",
},
{
agentId,
runId,
type: "slack.message.post",
provider: "slack",
summary: "Already posted",
status: "SUCCEEDED",
idempotencyKey: `${runId}:done`,
requestHash: "done",
},
],
});
await service.cancelRun({ id: agentId, runId }, userId);
const actions = await db.agentAction.findMany({
where: { runId },
orderBy: { idempotencyKey: "asc" },
select: { status: true },
});
expect(actions.map((action) => action.status)).toEqual([
"SUCCEEDED",
"CANCELLED",
]);
});
it("is idempotent and never pokes twice", async () => {
const runId = await queuedRun();
await service.cancelRun({ id: agentId, runId }, userId);
cancelPokes = [];
const again = await service.cancelRun({ id: agentId, runId }, userId);
expect(again.cancelled).toBe(false);
expect(again.status).toBe("CANCELLED");
expect(cancelPokes).toEqual([]);
expect(
await db.agentRunEvent.count({ where: { runId, type: "run.cancelled" } }),
).toBe(1);
});
it("leaves a finished run alone", async () => {
const runId = await queuedRun();
await db.agentRun.update({
where: { id: runId },
data: { status: "SUCCEEDED", finishedAt: new Date() },
});
const result = await service.cancelRun({ id: agentId, runId }, userId);
expect(result).toMatchObject({ status: "SUCCEEDED", cancelled: false });
expect(cancelPokes).toEqual([]);
});
it("refuses a run id that belongs to another agent", async () => {
const runId = await queuedRun();
const other = await db.agentDefinition.create({
data: { name: "Unrelated", status: "LIVE", createdById: userId },
select: { id: true },
});
let error: Error | null = null;
try {
await service.cancelRun({ id: other.id, runId }, userId);
} catch (caught) {
error = caught as Error;
}
expect(error?.message).toBe(`No run with id ${runId}.`);
});
it("refuses a caller who is not a workspace member", async () => {
const runId = await queuedRun();
let error: Error | null = null;
try {
await service.cancelRun({ id: agentId, runId }, outsiderId);
} catch (caught) {
error = caught as Error;
}
expect(error?.message).toBe("You are not a member of this workspace.");
});
it("reports cancellable runs to the caller who may stop them", async () => {
const runId = await queuedRun();
const history = await service.list(agentId, 50, userId);
const row = history.find((run) => run.id === runId);
expect(row?.canCancel).toBe(true);
await service.cancelRun({ id: agentId, runId }, userId);
const settled = await service.list(agentId, 50, userId);
expect(settled.find((run) => run.id === runId)?.canCancel).toBe(false);
});
it("asks the agent again until the cancellation lands", async () => {
const runId = await queuedRun();
await db.agentRun.update({
where: { id: runId },
data: { status: "RUNNING", startedAt: new Date() },
});
await service.cancelRun({ id: agentId, runId }, userId);
const trigger = new AgentTriggerService(db);
const asked: string[] = [];
const asksForRun = () => asked.filter((id) => id === runId).length;
let status = 502;
const realFetch = globalThis.fetch;
const realSecret = process.env.AGENT_BRIDGE_SECRET;
process.env.AGENT_BRIDGE_SECRET = "run-cancel-test";
globalThis.fetch = (async (
_url: string | URL | Request,
init?: RequestInit,
) => {
const body = JSON.parse(String(init?.body)) as { runId: string };
asked.push(body.runId);
return new Response(null, { status });
}) as typeof fetch;
try {
await trigger.redeliverCancellations();
expect(asksForRun()).toBe(1);
status = 202;
await trigger.redeliverCancellations();
expect(asksForRun()).toBe(2);
await trigger.redeliverCancellations();
expect(asksForRun()).toBe(2);
} finally {
globalThis.fetch = realFetch;
if (realSecret === undefined) {
delete process.env.AGENT_BRIDGE_SECRET;
} else {
process.env.AGENT_BRIDGE_SECRET = realSecret;
}
}
});
});