202 lines
8.7 KiB
TypeScript
202 lines
8.7 KiB
TypeScript
// The agent module's use cases on the in-memory adapter: starting lists and statuses, cancel's
|
|
// resume event, and the approval queue — which must surface the EXACT stored proposed arguments.
|
|
|
|
import { AGENT_ENTITIES, dataAgentPersistence, dataRunStore, threadIdOf } from "@conusai-kit/agent"
|
|
import type { TenantScope } from "@conusai-kit/core"
|
|
import { createMemoryDataSource } from "@conusai-kit/data"
|
|
import { describe, expect, it } from "vitest"
|
|
import { cancelRun, getManyRuns, getRun, listApprovals, listRuns, reviewApproval, startRun } from "../core/runs.js"
|
|
|
|
const USER = "01900000-0000-7000-0000-000000000009"
|
|
const scope: TenantScope = {
|
|
level: "project",
|
|
actor: { userId: USER },
|
|
orgId: "01900000-0000-7000-0000-000000000001",
|
|
workspaceId: "01900000-0000-7000-0000-000000000002",
|
|
projectId: "01900000-0000-7000-0000-000000000003",
|
|
}
|
|
const makeDeps = () => ({ data: createMemoryDataSource({ entities: [...AGENT_ENTITIES] }) })
|
|
|
|
const PLAN = [
|
|
{ key: "read", label: "Read the document", tool: "documents.read", args: { fileId: "f-1" } },
|
|
{ key: "propose", label: "Propose lines", tool: "documents.extract", args: { fileId: "f-1", schema: "line" } },
|
|
]
|
|
|
|
describe("the agent module's run use cases", () => {
|
|
const deps = makeDeps()
|
|
it("starts a run queued, with the plan visible, and lists it", async () => {
|
|
const run = await startRun(deps, scope, { goal: "Review the contract", plan: PLAN })
|
|
expect(run.status).toBe("queued")
|
|
expect(run.goal).toBe("Review the contract")
|
|
expect(run.plan).toEqual([
|
|
{
|
|
key: "read",
|
|
label: "Read the document",
|
|
tool: "documents.read",
|
|
args: { fileId: "f-1" },
|
|
needsApproval: false,
|
|
status: "pending",
|
|
attempts: 0,
|
|
error: null,
|
|
},
|
|
{
|
|
key: "propose",
|
|
label: "Propose lines",
|
|
tool: "documents.extract",
|
|
args: { fileId: "f-1", schema: "line" },
|
|
needsApproval: false,
|
|
status: "pending",
|
|
attempts: 0,
|
|
error: null,
|
|
},
|
|
])
|
|
expect(run.percent).toBe(0)
|
|
expect(run.answer).toBeNull()
|
|
const listed = await listRuns(deps, scope, {})
|
|
expect(listed.runs).toHaveLength(1)
|
|
expect((await getRun(deps, scope, run.runId)).runId).toBe(run.runId)
|
|
// The outbox event that enqueues the run job in the worker.
|
|
const pending = await deps.data.outbox.pending(10)
|
|
expect(pending.some((record) => record.name === "agent.runResumeRequested")).toBe(true)
|
|
})
|
|
|
|
it("reads runs back by id for the live list, and answers nothing for another project's or no run", async () => {
|
|
const own = makeDeps()
|
|
const run = await startRun(own, scope, { goal: "Read back", plan: PLAN })
|
|
const listed = (await listRuns(own, scope, {})).runs
|
|
expect(await getManyRuns(own, scope, [run.runId, run.runId])).toEqual(listed)
|
|
const elsewhere: TenantScope = { ...scope, projectId: "01900000-0000-7000-0000-000000000004" }
|
|
expect(await getManyRuns(own, elsewhere, [run.runId])).toEqual([])
|
|
expect(await getManyRuns(own, scope, ["01900000-0000-7000-0000-0000000000ff"])).toEqual([])
|
|
})
|
|
|
|
it("answers a completed run's answer with the provenance it is stored with (AI Act Art. 50(2))", async () => {
|
|
const fresh = makeDeps()
|
|
const run = await startRun(fresh, scope, { goal: "Review the contract", plan: PLAN })
|
|
expect(run.answerProvenance).toBeNull()
|
|
const provenance = {
|
|
ai_generated: true as const,
|
|
mode: "machine-generated" as const,
|
|
digital_source_type: "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia",
|
|
generator: "conusai.ai-gateway",
|
|
provider: "openai",
|
|
model: "gpt-4o-mini-2024-07-18",
|
|
generated_at: "2026-11-02T10:30:00Z",
|
|
}
|
|
const store = dataRunStore(fresh.data, scope)
|
|
const record = await store.get(run.runId)
|
|
await store.transition(run.runId, record?.version ?? 0, {
|
|
status: "completed",
|
|
finishedAt: "2026-11-02T10:30:01.000Z",
|
|
answerProvenance: provenance,
|
|
})
|
|
await dataAgentPersistence(fresh.data, scope).stores.messages.saveThread(threadIdOf(run.runId), [
|
|
{ role: "user", content: "Review the contract" },
|
|
{ role: "assistant", content: "The contract was reviewed." },
|
|
])
|
|
const completed = await getRun(fresh, scope, run.runId)
|
|
expect(completed.answer).toBe("The contract was reviewed.")
|
|
expect(completed.answerProvenance).toEqual(provenance)
|
|
})
|
|
|
|
it("refuses an over-long or repeated plan before anything is written", async () => {
|
|
const fresh = makeDeps()
|
|
const tooLong = await startRun(fresh, scope, {
|
|
goal: "x",
|
|
plan: Array.from({ length: 26 }, (_, at) => ({ key: `s${at}`, label: `Step ${at}`, tool: "t", args: {} })),
|
|
}).catch((error: unknown) => error)
|
|
expect((tooLong as { status?: number }).status).toBe(422)
|
|
const repeated = await startRun(fresh, scope, {
|
|
goal: "x",
|
|
plan: [
|
|
{ key: "same", label: "One", tool: "t", args: {} },
|
|
{ key: "same", label: "Two", tool: "t", args: {} },
|
|
],
|
|
}).catch((error: unknown) => error)
|
|
expect((repeated as { status?: number }).status).toBe(422)
|
|
expect((await listRuns(fresh, scope, {})).runs).toHaveLength(0)
|
|
})
|
|
|
|
it("cancel persists the request and re-enqueues the resume; a parked approval surfaces its exact arguments", async () => {
|
|
const fresh = makeDeps()
|
|
const run = await startRun(fresh, scope, { goal: "Approve-aware run", plan: PLAN })
|
|
// Simulate the engine parking an approval by writing the step row as the engine would.
|
|
const { dataRunStore } = await import("@conusai-kit/agent")
|
|
const store = dataRunStore(fresh.data, scope)
|
|
|
|
await store.parkStepApproval(
|
|
run.runId,
|
|
{ key: "read", index: 0, label: "Read the document" },
|
|
{
|
|
actionId: "act-7",
|
|
tool: "documents.read",
|
|
arguments: { fileId: "f-1", dryRun: false },
|
|
reviewUrl: "https://console/review?action=act-7",
|
|
interrupt: null,
|
|
},
|
|
new Date().toISOString(),
|
|
)
|
|
await fresh.data
|
|
.forScope(scope)
|
|
// biome-ignore lint/suspicious/noExplicitAny: test adjusts the run's status as the engine would.
|
|
.of(AGENT_ENTITIES[0] as any)
|
|
.update(run.runId, { status: "awaiting_approval" }, 1)
|
|
|
|
const queue = await listApprovals(fresh, scope)
|
|
expect(queue.approvals).toHaveLength(1)
|
|
expect(queue.approvals[0]).toMatchObject({
|
|
runId: run.runId,
|
|
stepKey: "read",
|
|
tool: "documents.read",
|
|
arguments: { fileId: "f-1", dryRun: false },
|
|
reviewUrl: "https://console/review?action=act-7",
|
|
})
|
|
|
|
const cancelled = await cancelRun(fresh, scope, run.runId)
|
|
expect(cancelled.cancelled).toBe(true)
|
|
expect((await getRun(fresh, scope, run.runId)).cancelRequested).toBe(true)
|
|
// The cancel re-published the resume event: a parked run notices the request only when resumed.
|
|
const pending = await fresh.data.outbox.pending(10)
|
|
expect(pending.filter((record) => record.name === "agent.runResumeRequested")).toHaveLength(2)
|
|
|
|
const review = await reviewApproval(fresh, scope, { runId: run.runId, stepKey: "read", decision: "approve" })
|
|
expect(["queued", "running", "awaiting_approval", "cancelled"]).toContain(review.status)
|
|
const bad = await reviewApproval(fresh, scope, { runId: run.runId, stepKey: "propose", decision: "approve" }).catch(
|
|
(error: unknown) => error,
|
|
)
|
|
expect((bad as { status?: number }).status).toBe(422)
|
|
// The decision is recorded on the step: the queue no longer offers it, and it is not decided twice.
|
|
expect((await listApprovals(fresh, scope)).approvals).toHaveLength(0)
|
|
const again = await reviewApproval(fresh, scope, { runId: run.runId, stepKey: "read", decision: "reject" }).catch(
|
|
(error: unknown) => error,
|
|
)
|
|
expect((again as { status?: number }).status).toBe(409)
|
|
expect((await store.listSteps(run.runId))[0]?.approval?.decision).toBe("approved")
|
|
})
|
|
})
|
|
|
|
it("does not offer or accept a pending approval after its run failed", async () => {
|
|
const fresh = makeDeps()
|
|
const run = await startRun(fresh, scope, { goal: "Synthetic approval", plan: PLAN })
|
|
const store = dataRunStore(fresh.data, scope)
|
|
await store.parkStepApproval(
|
|
run.runId,
|
|
{ key: "read", index: 0, label: "Read" },
|
|
{
|
|
actionId: null,
|
|
tool: "records.write",
|
|
arguments: {},
|
|
reviewUrl: null,
|
|
interrupt: null,
|
|
},
|
|
new Date().toISOString(),
|
|
)
|
|
const record = await store.get(run.runId)
|
|
if (!record) throw new Error("expected a run")
|
|
await store.transition(run.runId, record.version, { status: "failed", failureCode: "budget_exhausted" })
|
|
expect((await listApprovals(fresh, scope)).approvals).toEqual([])
|
|
await expect(
|
|
reviewApproval(fresh, scope, { runId: run.runId, stepKey: "read", decision: "approve" }),
|
|
).rejects.toMatchObject({ status: 409 })
|
|
})
|