@sixb/core 0.1.21 → 0.1.22

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

@@ -251,6 +251,10 @@ export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
               textOutputTokens: 0,
               reasoningOutputTokens: 0,
               audioDurationMs: 0,
+              imageOutputTokens: 0,
+              audioOutputTokens: 0,
+              outputImages: 0,
+              inputCharacters: 0,
             },
           },
           costs: {
@@ -261,6 +265,22 @@ export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
           },
         })
         expect(overview.series).toMatchObject([{ modelCallCount: 3 }])
+        // Removal proof: drop the kind dimension from a storage's overview; kinds come back empty.
+        expect(
+          overview.kinds.map((kind) => ({
+            modelKind: kind.modelKind,
+            modelCallCount: kind.modelCallCount,
+            amounts: kind.costs.amounts,
+          }))
+        ).toEqual([
+          { modelKind: "image", modelCallCount: 1, amounts: [] },
+          {
+            modelKind: "language",
+            modelCallCount: 1,
+            amounts: [{ currency: "USD", amountNanos: "95000" }],
+          },
+          { modelKind: undefined, modelCallCount: 1, amounts: [] },
+        ])
         expect(overview.models).toMatchObject([
           { providerId: "gateway", modelId: "openai/gpt-5", modelCallCount: 2 },
           { providerId: "gateway", modelId: "unpriced/model", modelCallCount: 1 },
@@ -447,14 +467,23 @@ export async function seedAiCostStorageContractUsage(
   }
 
   for (const fixture of [
-    { id: "usage_1", model: "openai/gpt-5", input: 12, output: 8, reasoning: "high" as const },
+    {
+      id: "usage_1",
+      model: "openai/gpt-5",
+      kind: "language" as const,
+      input: 12,
+      output: 8,
+      reasoning: "high" as const,
+    },
     {
       id: "usage_2",
       model: "unpriced/model",
+      kind: "image" as const,
       input: 1,
       output: 1,
       reasoning: { budgetTokens: 4_096 },
     },
+    // Recorded before calls captured their kind.
     { id: "usage_3", model: "openai/gpt-5", input: 2, output: 3, reasoning: undefined },
   ]) {
     await usage.recordModelCall({
@@ -466,6 +495,7 @@ export async function seedAiCostStorageContractUsage(
       requesterGroupIds: [],
       providerId: "gateway",
       requestedModelId: fixture.model,
+      ...("kind" in fixture ? { modelKind: fixture.kind } : {}),
       ...(fixture.reasoning === undefined ? {} : { requestedReasoning: fixture.reasoning }),
       responseId: `response_${projectId}_${fixture.id}`,
       usage: {

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

@@ -539,7 +539,7 @@ export function runAiLimitStorageContractSuite<TStorage extends AiLimitStorageCo
 
     // Removal proof: drop aiLimitMeterApplies from a provider's reserve loop (admission reports
     // missingEstimate) or from resolveAiLimitActual (the meter becomes unavailable).
-    test("token limits neither admit nor count transcription and reranking", async () => {
+    test("token limits neither admit nor count tokenless model kinds", async () => {
       await withStorage(async (storage) => {
         const status = async () =>
           (
@@ -570,11 +570,13 @@ export function runAiLimitStorageContractSuite<TStorage extends AiLimitStorageCo
           meter: "cost.catalogEstimated",
           amount: { currency: "USD", amountNanos: "100" },
         }
-        await expect(
-          storage.aiLimits.reserveModelCall(
-            reservation("reranking", 0, { estimates: [cost], modelKind: "reranking" })
-          )
-        ).resolves.toEqual({ status: "notRequired" })
+        for (const modelKind of ["reranking", "image", "speech"] as const) {
+          await expect(
+            storage.aiLimits.reserveModelCall(
+              reservation(modelKind, 0, { estimates: [cost], modelKind })
+            )
+          ).resolves.toEqual({ status: "notRequired" })
+        }
         await expect(
           storage.aiLimits.reserveModelCall(reservation("language", 0, { estimates: [cost] }))
         ).resolves.toMatchObject({ status: "unavailable", reasons: ["missingEstimate"] })
@@ -1035,7 +1037,7 @@ export function runAiLimitStorageContractSuite<TStorage extends AiLimitStorageCo
   })
 }
 
-export async function seedAiLimitStorageContractExecution(
+async function seedAiLimitStorageContractExecution(
   auth: AuthStorage,
   executions: ExecutionStorage
 ): Promise<void> {

package/src/testing/ai-model-call-groups-contract.ts

@@ -96,6 +96,80 @@ export function runAiModelCallGroupsContractSuite<T extends AiModelCallGroupsCon
       }
     })
 
+    // Removal proof: drop tokenless_count from a storage's group query (or tokenlessCount from
+    // summarize); the mixed run then hides its token total behind the image call.
+    test("sums media per run, and tokenless calls leave no gap in its tokens", async () => {
+      const storage = await options.createStorage()
+      try {
+        await options.setup?.(storage)
+        const runs = {
+          mixed: [
+            { kind: "language", usage: { inputTokens: 2, outputTokens: 3 } },
+            { kind: "image", usage: { outputImages: 2 } },
+            { kind: "speech", usage: { inputCharacters: 12, audioDurationMs: 1160 } },
+          ],
+          images: [{ kind: "image", usage: { outputImages: 1 } }],
+          gap: [
+            { kind: "language", usage: {} },
+            { kind: "image", usage: { outputImages: 1 } },
+          ],
+        } as const
+        for (const [id, calls] of Object.entries(runs)) {
+          const execution = await storage.executions.create({
+            projectId,
+            id,
+            executor: { type: "request", requestId: id },
+            source: { type: "http", requestId: id },
+            correlationId: id,
+            authorizationRef: { type: "disabled" },
+          })
+          for (const [index, call] of calls.entries()) {
+            await storage.aiUsage.recordModelCall({
+              projectId,
+              id: `${id}:${index}`,
+              executionId: execution.id,
+              attempt: 1,
+              callId: `${id}:${index}`,
+              requesterGroupIds: [],
+              providerId: "test",
+              requestedModelId: call.kind,
+              modelKind: call.kind,
+              responseId: `${id}:${index}`,
+              usage: call.usage,
+              occurredAt: new Date("2026-09-01T12:00:00Z"),
+            })
+          }
+        }
+
+        const groups = await storage.aiCosts.listModelCallGroups(range)
+        const group = (id: string) => {
+          const found = groups.items.find((item) => item.executionId === id)
+          return {
+            totalTokens: found?.totalTokens,
+            outputImages: found?.outputImages,
+            inputCharacters: found?.inputCharacters,
+            audioDurationMs: found?.audioDurationMs,
+          }
+        }
+        expect(group("mixed")).toEqual({
+          totalTokens: 5,
+          outputImages: 2,
+          inputCharacters: 12,
+          audioDurationMs: 1160,
+        })
+        expect(group("images")).toEqual({
+          totalTokens: undefined,
+          outputImages: 1,
+          inputCharacters: undefined,
+          audioDurationMs: undefined,
+        })
+        // A language call without tokens is a real gap.
+        expect(group("gap").totalTokens).toBeUndefined()
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+
     test("attributes workflow usage to step references and keeps same-named steps separate", async () => {
       const storage = await options.createStorage()
       try {
@@ -376,6 +450,8 @@ async function seed(storage: AiModelCallGroupsContractStorage) {
           toolNames: [],
           maxSteps: 25,
         },
+        thread: { id: "child_thread", create: true },
+        trigger: { id: "child_task", parts: [{ type: "text", text: "Research" }] },
         maxActiveChildren: 4,
       })
     }

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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from "bun:test"
+import type { FileRef } from "../blob-storage/types"
 import {
   type AiUsageStorage,
   AiUsageStorageError,
@@ -70,34 +71,82 @@ export function runAiUsageStorageContractSuite<TStorage extends AiUsageStorage>(
 
   describe(label, () => {
     // Removal proof: omit audioDurationMs from a row codec; this round trip fails.
-    test("persists transcription usage and kind without invented token totals", async () => {
+    // Removal proof: omit 'reranking' from a storage migration's model_kind check; the write fails.
+    test("persists transcription and reranking usage kinds without invented token totals", async () => {
       await withStorage(async (storage) => {
+        const latest = () =>
+          storage.getLatestForExecution({ projectId, executionId: agentExecutionId })
         const input = modelCallInput({
           modelKind: "transcription",
           usage: { audioDurationMs: 1250 },
         })
         await storage.recordModelCall(input)
-        const latest = await storage.getLatestForExecution({
-          projectId,
-          executionId: agentExecutionId,
+        expect((await latest())?.modelKind).toBe("transcription")
+        expect((await latest())?.usage).toEqual({
+          audioDurationMs: 1250,
+          reportingStatus: "partial",
         })
-        expect(latest?.modelKind).toBe("transcription")
-        expect(latest?.usage).toEqual({ audioDurationMs: 1250, reportingStatus: "partial" })
         expect((await storage.recordModelCall(input)).created).toBe(false)
         expect(
           await storage.summarizeExecution({ projectId, executionId: agentExecutionId })
         ).toMatchObject({ modelCallCount: 1, usage: { audioDurationMs: 1250 } })
+
+        await storage.recordModelCall(
+          modelCallInput({
+            id: "usage_reranking",
+            callId: "call_reranking",
+            responseId: "response_reranking",
+            modelKind: "reranking",
+            usage: {},
+            occurredAt: at("2026-06-23T10:01:00.000Z"),
+          })
+        )
+        expect((await latest())?.modelKind).toBe("reranking")
       })
     })
-    // Removal proof: omit 'reranking' from a storage migration's model_kind check; the write fails.
-    test("persists reranking usage kind", async () => {
+    // Removal proof: omit a media count from a row codec, or 'speech' from a storage migration's
+    // model_kind check; the round trip or the write fails.
+    test("persists generated-media usage and the speech kind", async () => {
       await withStorage(async (storage) => {
-        await storage.recordModelCall(modelCallInput({ modelKind: "reranking", usage: {} }))
-        const latest = await storage.getLatestForExecution({
-          projectId,
-          executionId: agentExecutionId,
+        const latest = () =>
+          storage.getLatestForExecution({ projectId, executionId: agentExecutionId })
+        await storage.recordModelCall(
+          modelCallInput({
+            modelKind: "speech",
+            usage: { inputCharacters: 12, audioOutputTokens: 29, audioDurationMs: 1160 },
+          })
+        )
+        expect((await latest())?.modelKind).toBe("speech")
+        expect((await latest())?.usage).toEqual({
+          inputCharacters: 12,
+          audioOutputTokens: 29,
+          audioDurationMs: 1160,
+          reportingStatus: "partial",
+        })
+
+        await storage.recordModelCall(
+          modelCallInput({
+            id: "usage_image",
+            callId: "call_image",
+            responseId: "response_image",
+            modelKind: "image",
+            usage: {
+              inputTokens: 14,
+              outputTokens: 1120,
+              imageOutputTokens: 1120,
+              outputImages: 1,
+            },
+            occurredAt: at("2026-06-23T10:01:00.000Z"),
+          })
+        )
+        expect((await latest())?.usage).toEqual({
+          inputTokens: 14,
+          outputTokens: 1120,
+          totalTokens: 1134,
+          imageOutputTokens: 1120,
+          outputImages: 1,
+          reportingStatus: "complete",
         })
-        expect(latest?.modelKind).toBe("reranking")
       })
     })
     test("retains native provider IDs across reads and replay", async () => {
@@ -590,9 +639,67 @@ export function runAiUsageStorageContractSuite<TStorage extends AiUsageStorage>(
         })
       })
     })
+
+    test("records a call's files once, for the execution that made it", async () => {
+      await withStorage(async (storage) => {
+        const files = [generatedFile("a"), { ...generatedFile("b"), fileName: "voice.mp3" }]
+        const input = {
+          projectId,
+          executionId: agentExecutionId,
+          callId: "call_image",
+          files,
+          recordedAt: at("2026-06-23T10:00:02.000Z"),
+        }
+        const recorded = await storage.recordModelCallFiles(input)
+        expect(recorded).toEqual(input)
+        expect(await storage.getModelCallFiles({ projectId, callId: "call_image" })).toEqual(input)
+
+        // A retry keeps the first record; another execution cannot claim the call.
+        expect(
+          await storage.recordModelCallFiles({ ...input, files: [generatedFile("c")] })
+        ).toEqual(input)
+        const conflict = await storage
+          .recordModelCallFiles({ ...input, executionId: otherAgentExecutionId })
+          .catch((error) => error)
+        expect(conflict).toBeInstanceOf(AiUsageStorageError)
+        expect(conflict).toMatchObject({ code: "duplicate_id" })
+
+        expect(await storage.getModelCallFiles({ projectId, callId: "call_other" })).toBeNull()
+        expect(
+          await storage.getModelCallFiles({ projectId: "other-project", callId: "call_image" })
+        ).toBeNull()
+      })
+    })
+
+    test("refuses files without a known execution or a valid reference", async () => {
+      await withStorage(async (storage) => {
+        const input = {
+          projectId,
+          executionId: agentExecutionId,
+          callId: "call_image",
+          files: [generatedFile("a")],
+        }
+        const missing = await storage
+          .recordModelCallFiles({ ...input, executionId: "exec_missing" })
+          .catch((error) => error)
+        expect(missing).toMatchObject({ code: "missing_execution" })
+        for (const files of [[], [{ ...generatedFile("a"), blobId: "blob_other" }]]) {
+          const invalid = await storage
+            .recordModelCallFiles({ ...input, files })
+            .catch((error) => error)
+          expect(invalid).toBeInstanceOf(TypeError)
+        }
+        expect(await storage.getModelCallFiles({ projectId, callId: "call_image" })).toBeNull()
+      })
+    })
   })
 }
 
+function generatedFile(seed: string): FileRef {
+  const digest = `sha256:${seed.repeat(64).slice(0, 64)}` as const
+  return { blobId: `blob_${digest.slice(7)}`, digest, sizeBytes: 3, mediaType: "image/png" }
+}
+
 /** Seed the immutable execution references used by the provider-neutral AI usage contract. */
 export async function seedAiUsageStorageContractExecutions(
   executions: ExecutionStorage