@sixb/core 0.1.6 → 0.1.8

package/src/testing/agent-storage-contract.ts

@@ -11,6 +11,7 @@ import {
   type CreateAgentContextCheckpointInput,
   type CreateAgentRunInput,
   type CreateAgentThreadInput,
+  type CreateSubagentRunInput,
   type StartAgentRunInput,
 } from "../storage/agents"
 import type { AuthStorage } from "../storage/auth"
@@ -65,7 +66,6 @@ function threadInput(overrides: Partial<CreateAgentThreadInput> = {}): CreateAge
   return {
     id: "thr_1",
     projectId,
-    agentId: "sales",
     ownerPrincipal: owner,
     createdAt: at("2026-06-23T10:00:00.000Z"),
     ...overrides,
@@ -90,8 +90,8 @@ function runInput(overrides: Partial<TestRunInput> = {}): TestRunInput {
     id: "run_1",
     projectId,
     threadId: "thr_1",
-    agentId: "sales",
     triggerMessageId: "msg_user_1",
+    spec: { model: { provider: "test", modelId: "large" } },
     executionId: "test_agent_execution:run_1",
     requesterGroupIds: ["support", "engineering", "support"],
     execution: execution("exec_1"),
@@ -104,6 +104,74 @@ function runInput(overrides: Partial<TestRunInput> = {}): TestRunInput {
   }
 }
 
+function subagentInput(
+  parentExecutionToken: string,
+  overrides: Partial<CreateSubagentRunInput> = {}
+): CreateSubagentRunInput {
+  const id = overrides.id ?? "child_1"
+  return {
+    id,
+    projectId,
+    executionId: overrides.executionId ?? `test_agent_execution:${id}`,
+    parentRunId: "parent_1",
+    parentExecutionToken,
+    spawnKey: "research-orders",
+    spec: {
+      model: { provider: "test", modelId: "small" },
+      reasoning: "medium",
+      task: "Research the open orders.",
+      toolNames: ["search_orders"],
+      maxSteps: 25,
+    },
+    maxActiveChildren: 4,
+    createdAt: at("2026-06-23T10:01:00.000Z"),
+    ...overrides,
+  }
+}
+
+async function createRunningParent(
+  storage: AgentStorage,
+  fixture: AgentStorageContractStorage
+): Promise<void> {
+  await storage.threads.create(threadInput({ id: "parent_thread" }))
+  const parent = runInput({
+    id: "parent_1",
+    threadId: "parent_thread",
+    execution: execution("parent_token"),
+  })
+  await createTestAgentExecution(fixture, {
+    projectId,
+    runId: parent.id,
+    executionId: parent.executionId,
+    authority: "inherited",
+  })
+  await storage.runs.create(parent)
+  await storage.runs.start({
+    projectId,
+    id: parent.id,
+    modelId: "large",
+    execution: parent.execution,
+  })
+}
+
+async function createSubagent(
+  storage: AgentStorage,
+  fixture: AgentStorageContractStorage,
+  overrides: Partial<CreateSubagentRunInput> = {}
+) {
+  const input = subagentInput("parent_token", overrides)
+  const parent = await storage.runs.getById({ projectId: input.projectId, id: input.parentRunId })
+  if (!parent || parent.kind !== "conversation") throw new Error("Expected child parent fixture")
+  await createTestAgentExecution(fixture, {
+    projectId: input.projectId,
+    runId: input.id,
+    executionId: input.executionId,
+    sourceExecutionId: parent.executionId,
+    authority: "inherited",
+  })
+  return storage.runs.createSubagent(input)
+}
+
 function checkpointInput(
   overrides: Partial<CreateAgentContextCheckpointInput> = {}
 ): CreateAgentContextCheckpointInput {
@@ -150,9 +218,9 @@ async function createRun(
 ) {
   await createTestAgentExecution(fixture, {
     projectId: input.projectId,
-    agentId: input.agentId,
     runId: input.id,
     executionId: input.executionId,
+    authority: "inherited",
   })
   return storage.runs.create(input)
 }
@@ -230,7 +298,6 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
         const thread = await storage.threads.create(threadInput({ title: "Q3 pipeline" }))
         expect(thread).toMatchObject({
           id: "thr_1",
-          agentId: "sales",
           title: "Q3 pipeline",
           status: "active",
           activeRunId: null,
@@ -256,19 +323,17 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
     test("lists threads with filters, ordering, and pagination", async () => {
       await withStorage(async (storage) => {
         await storage.threads.create(
-          threadInput({ id: "thr_a", agentId: "sales", createdAt: at("2026-06-23T10:00:00.000Z") })
+          threadInput({ id: "thr_a", createdAt: at("2026-06-23T10:00:00.000Z") })
         )
         await storage.threads.create(
           threadInput({
             id: "thr_b",
-            agentId: "support",
             createdAt: at("2026-06-23T10:01:00.000Z"),
           })
         )
         await storage.threads.create(
           threadInput({
             id: "thr_c",
-            agentId: "sales",
             status: "archived",
             createdAt: at("2026-06-23T10:02:00.000Z"),
           })
@@ -280,25 +345,6 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
         expect(all.total).toBe(3)
         expect(all.hasMore).toBe(false)
 
-        const sales = await storage.threads.list({ projectId, agentId: "sales", order: "asc" })
-        expect(sales.threads.map((thread) => thread.id)).toEqual(["thr_a", "thr_c"])
-
-        const visibleAgents = await storage.threads.list({
-          projectId,
-          agentIds: ["support"],
-          order: "asc",
-        })
-        expect(visibleAgents.threads.map((thread) => thread.id)).toEqual(["thr_b"])
-
-        const salesVisibleAgents = await storage.threads.list({
-          projectId,
-          agentId: "sales",
-          agentIds: ["support"],
-          order: "asc",
-        })
-        expect(salesVisibleAgents.threads).toEqual([])
-        expect(salesVisibleAgents.total).toBe(0)
-
         const active = await storage.threads.list({ projectId, statuses: ["active"], order: "asc" })
         expect(active.threads.map((thread) => thread.id)).toEqual(["thr_a", "thr_b"])
 
@@ -325,7 +371,12 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
         await storage.threads.create(threadInput())
 
         const queued = await createRun(storage, fixture, runInput({ id: "run_1" }))
-        expect(queued).toMatchObject({ status: "queued", attempt: 0, threadId: "thr_1" })
+        expect(queued).toMatchObject({
+          status: "queued",
+          attempt: 0,
+          threadId: "thr_1",
+          spec: { model: { provider: "test", modelId: "large" } },
+        })
         expect(queued.execution).toBeUndefined()
         expect(queued.startedAt).toBeUndefined()
         await expect(storage.runs.list({ projectId, statuses: ["queued"] })).resolves.toMatchObject(
@@ -357,7 +408,7 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
         await storage.threads.create(threadInput())
         const executionId = await createTestAgentExecution(fixture, {
           projectId,
-          agentId: "support",
+          actorId: "support",
           runId: "run_1",
         })
 
@@ -425,6 +476,176 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
       })
     })
 
+    // ── durable child runs ─────────────────────────────────────────────────────────────────────
+
+    test("creates and exactly replays a child run without claiming a thread", async () => {
+      await withStorage(async (storage, fixture) => {
+        await createRunningParent(storage, fixture)
+        const input = subagentInput("parent_token")
+        const child = await createSubagent(storage, fixture)
+
+        expect(child).toMatchObject({
+          kind: "subagent",
+          id: "child_1",
+          parentRunId: "parent_1",
+          spawnKey: "research-orders",
+          status: "queued",
+          attempt: 0,
+          requesterGroupIds: ["engineering", "support"],
+          spec: input.spec,
+        })
+        expect(child).not.toHaveProperty("threadId")
+        await expect(storage.runs.createSubagent(input)).resolves.toEqual(child)
+        await expectAgentError(
+          storage.runs.createSubagent({
+            ...input,
+            spec: { ...input.spec, task: "Research different orders." },
+          }),
+          "duplicate_id"
+        )
+
+        const listed = await storage.runs.list({
+          projectId,
+          kinds: ["subagent"],
+          parentRunId: "parent_1",
+        })
+        expect(listed.runs.map((run) => run.id)).toEqual(["child_1"])
+        await expect(
+          storage.runs.list({ projectId, kinds: ["conversation"] })
+        ).resolves.toMatchObject({ runs: [{ id: "parent_1" }], total: 1 })
+        await expect(
+          storage.threads.getById({ projectId, id: "parent_thread" })
+        ).resolves.toMatchObject({ activeRunId: "parent_1" })
+      })
+    })
+
+    test("fences child admission by the active parent execution", async () => {
+      await withStorage(async (storage, fixture) => {
+        await createRunningParent(storage, fixture)
+        const wrongLineage = subagentInput("parent_token", {
+          id: "child_wrong_parent",
+          executionId: "test_agent_execution:child_wrong_parent",
+          spawnKey: "wrong-parent",
+        })
+        await createTestAgentExecution(fixture, {
+          projectId,
+          runId: wrongLineage.id,
+          executionId: wrongLineage.executionId,
+          sourceExecutionId: "unrelated_request_execution",
+          authority: "inherited",
+        })
+        await expectAgentError(storage.runs.createSubagent(wrongLineage), "invalid_input")
+
+        const input = subagentInput("stale_parent_token")
+        await createTestAgentExecution(fixture, {
+          projectId,
+          runId: input.id,
+          executionId: input.executionId,
+          sourceExecutionId: "test_agent_execution:parent_1",
+          authority: "inherited",
+        })
+        await expectAgentError(storage.runs.createSubagent(input), "execution_lost")
+
+        await storage.runs.finish({
+          projectId,
+          id: "parent_1",
+          executionToken: "parent_token",
+          status: "succeeded",
+        })
+        await expectAgentError(
+          storage.runs.createSubagent({ ...input, parentExecutionToken: "parent_token" }),
+          "invalid_state"
+        )
+      })
+    })
+
+    test("enforces the active-child limit atomically", async () => {
+      await withStorage(async (storage, fixture) => {
+        await createRunningParent(storage, fixture)
+        const inputs = ["child_a", "child_b"].map((id) =>
+          subagentInput("parent_token", {
+            id,
+            executionId: `test_agent_execution:${id}`,
+            spawnKey: id,
+            maxActiveChildren: 1,
+          })
+        )
+        for (const input of inputs) {
+          await createTestAgentExecution(fixture, {
+            projectId,
+            runId: input.id,
+            executionId: input.executionId,
+            sourceExecutionId: "test_agent_execution:parent_1",
+            authority: "inherited",
+          })
+        }
+
+        const settled = await Promise.allSettled(
+          inputs.map((input) => storage.runs.createSubagent(input))
+        )
+        expect(settled.filter((result) => result.status === "fulfilled")).toHaveLength(1)
+        const rejected = settled.filter(
+          (result): result is PromiseRejectedResult => result.status === "rejected"
+        )
+        expect(rejected).toHaveLength(1)
+        expect(rejected[0]?.reason).toMatchObject({ code: "active_child_limit" })
+      })
+    })
+
+    test("requires and round-trips a successful child result", async () => {
+      await withStorage(async (storage, fixture) => {
+        await createRunningParent(storage, fixture)
+        await createSubagent(storage, fixture)
+        await storage.runs.start({
+          projectId,
+          id: "child_1",
+          modelId: "small",
+          execution: execution("child_token"),
+        })
+        await expectAgentError(
+          storage.runs.finish({
+            projectId,
+            id: "child_1",
+            executionToken: "child_token",
+            status: "succeeded",
+          }),
+          "invalid_input"
+        )
+        await expectAgentError(
+          storage.runs.finish({
+            projectId,
+            id: "child_1",
+            executionToken: "child_token",
+            status: "succeeded",
+            result: {},
+          }),
+          "invalid_input"
+        )
+
+        const result = {
+          text: "Three open orders.",
+          files: [
+            {
+              blobId: `blob_${"a".repeat(64)}`,
+              digest: `sha256:${"a".repeat(64)}` as const,
+              fileName: "orders.csv",
+              mediaType: "text/csv",
+              sizeBytes: 42,
+            },
+          ],
+        }
+        const completed = await storage.runs.finish({
+          projectId,
+          id: "child_1",
+          executionToken: "child_token",
+          status: "succeeded",
+          result,
+        })
+        expect(completed).toMatchObject({ status: "succeeded", result })
+        await expect(storage.runs.getById({ projectId, id: "child_1" })).resolves.toEqual(completed)
+      })
+    })
+
     // ── single-flight execution ─────────────────────────────────────────────────────────────────
 
     test("allows a single active run per thread", async () => {

package/src/testing/ai-cost-storage-contract.ts

@@ -68,8 +68,7 @@ function unpriceableCost(): Extract<AiModelCallCostRecord, { status: "unpriceabl
     status: "unpriceable",
     billingIdentity: { providerId: "vercel", modelId: "unpriced/model" },
     pricingContext: {},
-    priceSource: priceSource("vercel/unpriced/model"),
-    reason: "missingCatalogEntry",
+    reason: "missingRateCard",
     ratedAt: new Date("2026-08-01T12:00:00.200Z"),
   }
 }
@@ -99,7 +98,75 @@ export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
           })
         ).resolves.toMatchObject({
           total: 1,
-          items: [{ usage: { id: "usage_1" }, cost: ratedCost(), valuationStatus: "rated" }],
+          items: [
+            {
+              usage: {
+                id: "usage_1",
+              },
+              cost: ratedCost(),
+              valuationStatus: "rated",
+            },
+          ],
+        })
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+
+    test("retains named, budgeted, and absent reasoning in accounting listings", async () => {
+      // Regression proof: omit requested_reasoning in either SQL accounting usageFromRow decoder.
+      const storage = await fixture()
+      try {
+        const page = await storage.listModelCalls({
+          projectId,
+          from: new Date("2026-08-01T00:00:00.000Z"),
+          to: new Date("2026-08-02T00:00:00.000Z"),
+        })
+        expect(page.items.map(({ usage }) => [usage.id, usage.requestedReasoning])).toEqual([
+          ["usage_1", "high"],
+          ["usage_2", { budgetTokens: 4_096 }],
+          ["usage_3", undefined],
+        ])
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+
+    test("retains an estimate beside an inline provider cost without double counting", async () => {
+      // Removal proof: drop estimate from the cost codec/normalizer, or sum it into the selected cost.
+      const storage = await fixture()
+      try {
+        const local = ratedCost()
+        const estimate = {
+          status: "rated" as const,
+          money: local.money,
+          components: local.components,
+        }
+        const report: AiModelCallCostRecord = {
+          ...local,
+          status: "rated",
+          money: { currency: "USD", amountNanos: "80000" },
+          components: [],
+          priceSource: { ...priceSource("generation-1"), sourceId: "provider-reported" },
+          estimate,
+        }
+        await Promise.all([
+          storage.recordModelCallCost(report),
+          storage.recordModelCallCost(report),
+        ])
+        expect(
+          (await storage.summarizeExecutions({ projectId, executionIds: [executionId] }))[0]
+            ?.amounts
+        ).toEqual([{ currency: "USD", amountNanos: "80000" }])
+        const page = await storage.listModelCalls({
+          projectId,
+          from: new Date("2026-08-01"),
+          to: new Date("2026-08-02"),
+          valuationStatus: "rated",
+        })
+        expect(page.items[0]?.cost).toMatchObject({
+          money: { amountNanos: "80000" },
+          estimate,
         })
       } finally {
         await options.cleanup?.(storage)
@@ -115,11 +182,15 @@ export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
           status: "unpriceable",
           billingIdentity: { providerId: "openai", modelId: "gpt-5" },
           pricingContext: { deploymentId: "production" },
-          priceSource: priceSource("openai/gpt-5"),
           reason: "unsupportedPricingDimension",
           ratedAt: new Date("2026-08-03T12:00:00.200Z"),
         }
-        await storage.recordModelCallCost(unpriceableCost())
+        // Historical API allowed a report source even when no charge was available. This is
+        // ambiguous history, not a provider cost. Regression proof: classify solely by sourceId.
+        await storage.recordModelCallCost({
+          ...unpriceableCost(),
+          priceSource: { ...priceSource("unavailable-report"), sourceId: "provider-reported" },
+        })
         await storage.recordModelCallCost(deploymentCost)
         await expect(
           storage.listModelCalls({
@@ -238,6 +309,16 @@ export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
         const mismatchError = await storage.recordModelCallCost(mismatch).catch((value) => value)
         expect(mismatchError).toBeInstanceOf(AiCostStorageError)
         expect((mismatchError as AiCostStorageError).code).toBe("cost_mismatch")
+        // Removal proof: skip the estimate check in aiModelCallCostMatchesUsage; this is accepted.
+        await expect(
+          storage.recordModelCallCost({
+            ...base,
+            money: { currency: "USD", amountNanos: "1" },
+            components: [],
+            priceSource: { ...base.priceSource, sourceId: "provider-reported" },
+            estimate: { status: "rated", money: mismatch.money, components: mismatch.components },
+          })
+        ).rejects.toMatchObject({ code: "cost_mismatch" })
       } finally {
         await options.cleanup?.(storage)
       }
@@ -272,9 +353,15 @@ export async function seedAiCostStorageContractUsage(
   }
 
   for (const fixture of [
-    { id: "usage_1", model: "openai/gpt-5", input: 12, output: 8 },
-    { id: "usage_2", model: "unpriced/model", input: 1, output: 1 },
-    { id: "usage_3", model: "openai/gpt-5", input: 2, output: 3 },
+    { id: "usage_1", model: "openai/gpt-5", input: 12, output: 8, reasoning: "high" as const },
+    {
+      id: "usage_2",
+      model: "unpriced/model",
+      input: 1,
+      output: 1,
+      reasoning: { budgetTokens: 4_096 },
+    },
+    { id: "usage_3", model: "openai/gpt-5", input: 2, output: 3, reasoning: undefined },
   ]) {
     await usage.recordModelCall({
       id: fixture.id,
@@ -285,6 +372,7 @@ export async function seedAiCostStorageContractUsage(
       requesterGroupIds: [],
       providerId: "gateway",
       requestedModelId: fixture.model,
+      ...(fixture.reasoning === undefined ? {} : { requestedReasoning: fixture.reasoning }),
       responseId: `response_${projectId}_${fixture.id}`,
       usage: {
         inputTokens: fixture.input,