ConusAI vendor v0.1.0-dev.20261027+9b1131fb

modules/agent/__tests__/i18n.test.ts

@@ -0,0 +1,23 @@
+// The module's messages: en and lt declare the same keys, or a page in one language breaks.
+
+import { buildRegistry } from "@conusai-kit/core"
+import { tenancyModule } from "@conusai-kit/tenancy"
+import { describe, expect, it } from "vitest"
+import { agentModule } from "../index.js"
+
+describe("the agent module's messages", () => {
+  const catalogues = buildRegistry([tenancyModule, agentModule]).catalogues
+
+  it("declares en and lt, and every en key resolves in lt", () => {
+    const en = catalogues.en?.agent ?? {}
+    const lt = catalogues.lt?.agent ?? {}
+    const flatten = (tree: Record<string, unknown>, prefix = ""): string[] =>
+      Object.entries(tree).flatMap(([key, value]) =>
+        typeof value === "string" ? [`${prefix}${key}`] : flatten(value as Record<string, unknown>, `${prefix}${key}.`),
+      )
+    const enKeys = flatten(en)
+    const ltKeys = new Set(flatten(lt))
+    expect(enKeys.length).toBeGreaterThan(0)
+    for (const key of enKeys) expect(ltKeys.has(key), `agent.${key} has no Lithuanian message`).toBe(true)
+  })
+})

modules/agent/__tests__/isolation.ts

@@ -0,0 +1,38 @@
+// What the generated tenant-isolation suite needs of this module: seeds and one fixture per
+// tenant-scoped procedure, built from the OTHER tenant's ids.
+
+import type { TransportCaller } from "@conusai-kit/core"
+import type { IsolationFixture, IsolationTenant } from "@conusai-kit/testing"
+
+export interface ModuleIsolation {
+  seed(
+    call: TransportCaller,
+    inProject: { org: string; workspace: string; project: string },
+  ): Promise<Record<string, string>>
+  fixtures: Record<string, IsolationFixture>
+}
+
+const NOWHERE = "00000000-0000-0000-0000-000000000000"
+const inProjectOf = (t: IsolationTenant) => ({ org: t.orgSlug, workspace: t.workspaceSlug, project: t.projectSlug })
+const runOf = (t: IsolationTenant) => t.extra.agentRunId ?? NOWHERE
+
+const PLAN = [{ key: "read", label: "Read", tool: "documents.read", args: {} }]
+
+export const isolation: ModuleIsolation = {
+  async seed(call, inProject) {
+    const started = (await call.callByName("agent.run.start", { ...inProject, goal: "Seed run", plan: PLAN })) as {
+      runId: string
+    }
+    return { agentRunId: started.runId }
+  },
+  fixtures: {
+    "agent.run.start": { input: (t) => ({ ...inProjectOf(t), goal: "Intruder", plan: PLAN }) },
+    "agent.run.status": { input: (t) => ({ ...inProjectOf(t), runId: runOf(t) }) },
+    "agent.run.cancel": { input: (t) => ({ ...inProjectOf(t), runId: runOf(t) }) },
+    "agent.run.list": { input: (t) => inProjectOf(t) },
+    "agent.approval.list": { input: (t) => inProjectOf(t) },
+    "agent.approval.review": {
+      input: (t) => ({ ...inProjectOf(t), runId: runOf(t), stepKey: "read", decision: "approve" }),
+    },
+  },
+}

modules/agent/__tests__/migration.test.ts

@@ -0,0 +1,33 @@
+// The module's migration is its own file and exactly `schemaStatements()` over the agent runtime's
+// two entities (decision AT-D20).
+
+import { readFileSync } from "node:fs"
+import { AGENT_ENTITIES } from "@conusai-kit/agent"
+import { schemaStatements } from "@conusai-kit/data-kysely"
+import { describe, expect, it } from "vitest"
+import { agentModule } from "../index.js"
+
+function tablesOf(entities: Parameters<typeof schemaStatements>[0]): string {
+  const kernel = schemaStatements([]).length
+  return `${schemaStatements(entities)
+    .slice(kernel)
+    .map((statement) => `${statement};`)
+    .join("\n\n")}\n`
+}
+
+describe("the migration of the agent module", () => {
+  it("is its own file, exactly its two tables", async () => {
+    await expect(
+      `-- SPDX-License-Identifier: LicenseRef-ConusAI-Template-1.0\n${tablesOf(AGENT_ENTITIES)}`,
+    ).toMatchFileSnapshot("../migrations/0001_agent.sql")
+  })
+
+  it("is declared by the manifest, and every table is row-level secured", () => {
+    expect(agentModule.migrations).toEqual({ postgres: "migrations" })
+    const sql = readFileSync(new URL("../migrations/0001_agent.sql", import.meta.url), "utf8")
+    for (const table of ["agent_run", "agent_step"]) {
+      expect(sql).toContain(`create table "${table}"`)
+      expect(sql).toContain(`alter table "${table}" force row level security`)
+    }
+  })
+})

modules/agent/__tests__/runs.test.ts

@@ -0,0 +1,126 @@
+// 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 } 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, 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" },
+        status: "pending",
+        attempts: 0,
+        error: null,
+      },
+      {
+        key: "propose",
+        label: "Propose lines",
+        tool: "documents.extract",
+        args: { fileId: "f-1", schema: "line" },
+        status: "pending",
+        attempts: 0,
+        error: null,
+      },
+    ])
+    expect(run.percent).toBe(0)
+    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("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.beginStep(run.runId, { key: "read", index: 0, label: "Read the document" }, new Date().toISOString())
+    await store.parkStepApproval(
+      run.runId,
+      "read",
+      {
+        actionId: "act-7",
+        tool: "documents.read",
+        arguments: { fileId: "f-1", dryRun: false },
+        reviewUrl: "https://console/review?action=act-7",
+      },
+      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)
+  })
+})

modules/agent/__tests__/ui.test.tsx

@@ -0,0 +1,105 @@
+// The approval queue's markup: the EXACT stored proposed arguments are rendered (never a
+// narration), the Art. 50 disclosure rides with them, and the controls are named for a keyboard.
+
+import { buildRegistry } from "@conusai-kit/core"
+import { createI18n } from "@conusai-kit/i18n"
+import { TransportProvider } from "@conusai-kit/ui"
+import { renderToStaticMarkup } from "react-dom/server"
+import { describe, expect, it } from "vitest"
+import { appModules } from "../../index.js"
+import type { ApprovalView } from "../contract/index.js"
+import { ApprovalQueue } from "../ui/approval-queue.js"
+import { RunControls } from "../ui/run-controls.js"
+
+const catalogues = buildRegistry([...appModules]).catalogues
+const i18n = createI18n("en", { en: { agent: catalogues.en?.agent ?? {} } })
+const t = (key: string, values?: Record<string, string | number>) => i18n.message(`agent.${key}`, values)
+const failed = "That did not work: {detail}"
+const slugs = { org: "acme", workspace: "ws", project: "p" }
+
+const inProvider = (node: React.ReactNode) =>
+  renderToStaticMarkup(
+    <TransportProvider call={async () => undefined} describe={() => "x"}>
+      {node}
+    </TransportProvider>,
+  )
+
+const approval: ApprovalView = {
+  runId: "r1",
+  stepKey: "read",
+  goal: "Review the contract",
+  tool: "orders.create",
+  arguments: { total: 4200, currency: "EUR" },
+  reviewUrl: "https://console/tool-approvals?action=act-1",
+  createdAt: "2026-10-23T00:00:00.000Z",
+}
+
+const labels = {
+  heading: t("approvals.heading"),
+  empty: t("approvals.empty"),
+  proposed: t("approvals.proposed"),
+  review: t("approvals.review"),
+  approve: t("approvals.approve"),
+  reject: t("approvals.reject"),
+  decided: t("approvals.decided"),
+  disclosure: t("approvals.disclosure"),
+  failed,
+}
+
+describe("the approval queue", () => {
+  const html = inProvider(<ApprovalQueue slugs={slugs} approvals={[approval]} labels={labels} />)
+
+  it("renders the exact stored proposed arguments, pretty-printed, with the disclosure", () => {
+    // The exact stored arguments, HTML-escaped as any rendered text is.
+    expect(html).toContain("&quot;total&quot;: 4200")
+    expect(html).toContain("&quot;currency&quot;: &quot;EUR&quot;")
+    expect(html).toContain(t("approvals.disclosure"))
+    expect(html).toContain(t("approvals.proposed"))
+  })
+
+  it("names the decision controls and links the console review", () => {
+    expect(html).toContain(`>${t("approvals.approve")}<`)
+    expect(html).toContain(`>${t("approvals.reject")}<`)
+    expect(html).toContain('href="https://console/tool-approvals?action=act-1"')
+  })
+
+  it("announces an empty queue", () => {
+    const empty = inProvider(<ApprovalQueue slugs={slugs} approvals={[]} labels={labels} />)
+    expect(empty).toContain(t("approvals.empty"))
+  })
+})
+
+describe("the run controls", () => {
+  const labels = {
+    cancel: t("runs.cancel"),
+    cancelling: t("runs.cancelling"),
+    refresh: t("runs.refresh"),
+    failedHint: t("recovery.failedHint"),
+    cancelledHint: t("recovery.cancelledHint"),
+    uncertainHint: t("recovery.uncertainHint"),
+    budgetExhausted: t("recovery.budgetExhausted"),
+    approvalUnavailable: t("recovery.approvalUnavailable"),
+    toolError: t("recovery.toolError"),
+    planRefused: t("recovery.planRefused"),
+    internal: t("recovery.internal"),
+  }
+
+  it("offers cancel on an active run and recovery copy on an uncertain one", () => {
+    const active = inProvider(
+      <RunControls slugs={slugs} run={{ runId: "r1", status: "running", failureCode: null }} labels={labels} />,
+    )
+    expect(active).toContain(`>${t("runs.cancel")}<`)
+    const uncertain = inProvider(
+      <RunControls slugs={slugs} run={{ runId: "r1", status: "uncertain", failureCode: null }} labels={labels} />,
+    )
+    expect(uncertain).toContain(
+      t("recovery.uncertainHint")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll(String.fromCharCode(34), "&quot;")
+        .replaceAll(String.fromCharCode(39), "&#x27;"),
+    )
+    expect(uncertain).not.toContain(`>${t("runs.cancel")}<`)
+  })
+})