@sixb/core 0.1.2 → 0.1.3

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

@@ -0,0 +1,320 @@
+import { describe, expect, test } from "bun:test"
+import type { AiCostStorage, AiModelCallCostRecord } from "../storage/ai-cost"
+import { AiCostStorageError } from "../storage/ai-cost"
+import type { AiUsageStorage } from "../storage/ai-usage"
+import type { ExecutionStorage } from "../storage/executions"
+
+export interface AiStorageContractSuiteOptions<TStorage> {
+  readonly createStorage: () => TStorage | Promise<TStorage>
+  readonly setup?: (storage: TStorage) => void | Promise<void>
+  readonly cleanup?: (storage: TStorage) => void | Promise<void>
+}
+
+const projectId = "cost-contract-project"
+const executionId = "exec_cost_1"
+const otherExecutionId = "exec_cost_2"
+
+function priceSource(entry: string) {
+  return {
+    sourceId: "test-catalog",
+    sourceEntryId: entry,
+    sourceVersion: "test-catalog-v1",
+    sourceUrl: "https://example.test/ai-pricing.json",
+    observedAt: new Date("2026-08-01T00:00:00.000Z"),
+  }
+}
+
+function ratedCost(
+  usageRecordId = "usage_1",
+  overrides: Partial<Extract<AiModelCallCostRecord, { status: "rated" }>> = {}
+): Extract<AiModelCallCostRecord, { status: "rated" }> {
+  return {
+    projectId,
+    usageRecordId,
+    status: "rated",
+    billingIdentity: { providerId: "vercel", modelId: "openai/gpt-5" },
+    pricingContext: {},
+    priceSource: priceSource("vercel/openai/gpt-5"),
+    money: { currency: "USD", amountNanos: "95000" },
+    components: [
+      {
+        meter: "tokens.input.uncached",
+        quantity: "12",
+        rateAmountNanosPerMillion: "1250000000",
+        chargeAmountNanos: "15000",
+      },
+      {
+        meter: "tokens.input.cacheRead",
+        quantity: "0",
+        rateAmountNanosPerMillion: "125000000",
+        chargeAmountNanos: "0",
+      },
+      {
+        meter: "tokens.output.total",
+        quantity: "8",
+        rateAmountNanosPerMillion: "10000000000",
+        chargeAmountNanos: "80000",
+      },
+    ],
+    ratedAt: new Date("2026-08-01T12:00:00.200Z"),
+    ...overrides,
+  }
+}
+
+function unpriceableCost(): Extract<AiModelCallCostRecord, { status: "unpriceable" }> {
+  return {
+    projectId,
+    usageRecordId: "usage_2",
+    status: "unpriceable",
+    billingIdentity: { providerId: "vercel", modelId: "unpriced/model" },
+    pricingContext: {},
+    priceSource: priceSource("vercel/unpriced/model"),
+    reason: "missingCatalogEntry",
+    ratedAt: new Date("2026-08-01T12:00:00.200Z"),
+  }
+}
+
+export function runAiCostStorageContractSuite<TStorage extends AiCostStorage>(
+  name: string,
+  options: AiStorageContractSuiteOptions<TStorage>
+): void {
+  describe(name, () => {
+    async function fixture(): Promise<TStorage> {
+      const storage = await options.createStorage()
+      await options.setup?.(storage)
+      return storage
+    }
+
+    test("records model-call costs idempotently", async () => {
+      const storage = await fixture()
+      try {
+        await expect(storage.recordModelCallCost(ratedCost())).resolves.toBeUndefined()
+        await expect(storage.recordModelCallCost(ratedCost())).resolves.toBeUndefined()
+        await expect(
+          storage.listModelCalls({
+            projectId,
+            from: new Date("2026-08-01T00:00:00.000Z"),
+            to: new Date("2026-08-02T00:00:00.000Z"),
+            valuationStatus: "rated",
+          })
+        ).resolves.toMatchObject({
+          total: 1,
+          items: [{ usage: { id: "usage_1" }, cost: ratedCost(), valuationStatus: "rated" }],
+        })
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+
+    test("stores explicit unpriceable results and pricing context", async () => {
+      const storage = await fixture()
+      try {
+        const deploymentCost: AiModelCallCostRecord = {
+          projectId,
+          usageRecordId: "usage_deployment",
+          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())
+        await storage.recordModelCallCost(deploymentCost)
+        await expect(
+          storage.listModelCalls({
+            projectId,
+            from: new Date("2026-08-03T00:00:00.000Z"),
+            to: new Date("2026-08-04T00:00:00.000Z"),
+            valuationStatus: "unpriceable",
+          })
+        ).resolves.toMatchObject({
+          total: 1,
+          items: [{ cost: deploymentCost, valuationStatus: "unpriceable" }],
+        })
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+
+    test("summarizes and queries accounting without inventing missing costs", async () => {
+      const storage = await fixture()
+      try {
+        await storage.recordModelCallCost(ratedCost())
+        await storage.recordModelCallCost(unpriceableCost())
+        await expect(
+          storage.summarizeExecutions({ projectId, executionIds: [executionId] })
+        ).resolves.toEqual([
+          {
+            amounts: [{ currency: "USD", amountNanos: "95000" }],
+            ratedCallCount: 1,
+            unpriceableCallCount: 1,
+            unvaluedCallCount: 1,
+          },
+        ])
+
+        const overview = await storage.queryProjectOverview({
+          projectId,
+          from: new Date("2026-08-01T00:00:00.000Z"),
+          to: new Date("2026-08-02T00:00:00.000Z"),
+          bucket: "day",
+        })
+        expect(overview.totals).toEqual({
+          modelCallCount: 3,
+          usage: {
+            inputTokens: 15,
+            outputTokens: 12,
+            totalTokens: 27,
+            reportingStatus: "complete",
+          },
+          costs: {
+            amounts: [{ currency: "USD", amountNanos: "95000" }],
+            ratedCallCount: 1,
+            unpriceableCallCount: 1,
+            unvaluedCallCount: 1,
+          },
+        })
+        expect(overview.series).toMatchObject([{ modelCallCount: 3 }])
+        expect(overview.models).toMatchObject([
+          { providerId: "gateway", modelId: "openai/gpt-5", modelCallCount: 2 },
+          { providerId: "gateway", modelId: "unpriced/model", modelCallCount: 1 },
+        ])
+        await expect(
+          storage.queryProjectOverview({
+            projectId,
+            from: new Date("2026-08-01T00:00:00.000Z"),
+            to: new Date("2026-08-02T00:00:00.000Z"),
+            bucket: "day",
+            providerId: "gateway",
+            modelId: "unpriced/model",
+          })
+        ).resolves.toMatchObject({ totals: { modelCallCount: 1 } })
+        await expect(
+          storage.listModelCalls({
+            projectId,
+            from: new Date("2026-08-01T00:00:00.000Z"),
+            to: new Date("2026-08-02T00:00:00.000Z"),
+            limit: 1,
+            offset: 1,
+          })
+        ).resolves.toMatchObject({
+          total: 3,
+          hasMore: true,
+          items: [{ usage: { id: "usage_2" } }],
+        })
+        await expect(
+          storage.listModelCalls({
+            projectId,
+            from: new Date("2026-08-01T00:00:00.000Z"),
+            to: new Date("2026-08-02T00:00:00.000Z"),
+            valuationStatus: "unpriceable",
+          })
+        ).resolves.toMatchObject({
+          total: 1,
+          hasMore: false,
+          items: [{ usage: { id: "usage_2" }, valuationStatus: "unpriceable" }],
+        })
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+
+    test("rejects missing usage and mismatched billed quantities", async () => {
+      const storage = await fixture()
+      try {
+        const missing = ratedCost("missing")
+        const missingError = await storage.recordModelCallCost(missing).catch((value) => value)
+        expect(missingError).toBeInstanceOf(AiCostStorageError)
+        expect((missingError as AiCostStorageError).code).toBe("missing_usage")
+
+        const base = ratedCost()
+        const mismatch = ratedCost("usage_1", {
+          money: { currency: "USD", amountNanos: "96250" },
+          components: [
+            { ...base.components[0]!, quantity: "13", chargeAmountNanos: "16250" },
+            ...base.components.slice(1),
+          ],
+        })
+        const mismatchError = await storage.recordModelCallCost(mismatch).catch((value) => value)
+        expect(mismatchError).toBeInstanceOf(AiCostStorageError)
+        expect((mismatchError as AiCostStorageError).code).toBe("cost_mismatch")
+      } finally {
+        await options.cleanup?.(storage)
+      }
+    })
+  })
+}
+
+/** Seed immutable usage used by every cost-storage provider contract. */
+export async function seedAiCostStorageContractUsage(
+  executions: ExecutionStorage,
+  usage: AiUsageStorage
+): Promise<void> {
+  for (const fixture of [
+    { projectId, executionId },
+    { projectId, executionId: otherExecutionId },
+  ]) {
+    if (await executions.getById({ projectId: fixture.projectId, id: fixture.executionId }))
+      continue
+    const primitive = {
+      kind: "workflow" as const,
+      id: "ai-cost-contract",
+      runId: fixture.executionId,
+    }
+    await executions.create({
+      id: fixture.executionId,
+      projectId: fixture.projectId,
+      executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
+      source: { type: "event", eventId: `test_event:${fixture.executionId}` },
+      correlationId: `test_correlation:${fixture.executionId}`,
+      authorizationRef: { type: "trustedPrimitive", primitive },
+    })
+  }
+
+  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 },
+  ]) {
+    await usage.recordModelCall({
+      id: fixture.id,
+      projectId,
+      executionId,
+      attempt: 1,
+      callId: `call_${fixture.id}`,
+      requesterGroupIds: [],
+      providerId: "gateway",
+      requestedModelId: fixture.model,
+      responseId: `response_${projectId}_${fixture.id}`,
+      usage: {
+        inputTokens: fixture.input,
+        outputTokens: fixture.output,
+        ...(fixture.id === "usage_1"
+          ? { uncachedInputTokens: fixture.input, cacheReadInputTokens: 0 }
+          : {}),
+      },
+      occurredAt: new Date("2026-08-01T12:00:00.000Z"),
+      recordedAt: new Date("2026-08-01T12:00:00.100Z"),
+    })
+  }
+
+  await usage.recordModelCall({
+    id: "usage_deployment",
+    projectId,
+    executionId: otherExecutionId,
+    attempt: 1,
+    callId: "call_usage_deployment",
+    requesterGroupIds: [],
+    providerId: "openai.responses",
+    requestedModelId: "gpt-5",
+    responseId: "response_usage_deployment",
+    usage: {
+      inputTokens: 2,
+      outputTokens: 3,
+      uncachedInputTokens: 2,
+      cacheReadInputTokens: 0,
+    },
+    occurredAt: new Date("2026-08-03T12:00:00.000Z"),
+    recordedAt: new Date("2026-08-03T12:00:00.100Z"),
+  })
+}

package/src/testing/index.ts

@@ -7,6 +7,11 @@ export {
   type AgentStorageContractSuiteOptions,
   runAgentStorageContractSuite,
 } from "./agent-storage-contract"
+export {
+  type AiStorageContractSuiteOptions,
+  runAiCostStorageContractSuite,
+  seedAiCostStorageContractUsage,
+} from "./ai-cost-storage-contract"
 export {
   type AiUsageStorageContractSuiteOptions,
   runAiUsageStorageContractSuite,

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

@@ -55,6 +55,23 @@ const devices = defineDataset("storage_contract_devices", {
 const readings = defineDataset("storage_contract_readings", {
   schema: [col("device_id", "string"), col("at", "timestamp"), col("value", "float64")],
 })
+const ConflictDevice = defineObjectType({
+  id: "StorageContractConflictDevice",
+  name: "Conflict device",
+  properties: [
+    prop("id", "string", { primary: true, required: true }),
+    prop("name", "string", { required: true }),
+    prop("state", "string", { required: true }),
+  ],
+})
+const conflictDevices = defineDataset("storage_contract_conflict_devices", {
+  schema: [
+    col("id", "string"),
+    col("name", "string"),
+    col("state", "string"),
+    col("updated_at", "timestamp"),
+  ],
+})
 const deviceProjection = defineProjection("storage_contract_devices", Device)
   .fromDataset(devices)
   .properties({ id: "id", name: "name" })
@@ -71,14 +88,22 @@ const temperatureProjection = defineProjection(
 )
   .fromDataset(readings)
   .points({ objectId: "device_id", at: "at", value: "value" })
+const conflictDeviceProjection = defineProjection(
+  "storage_contract_conflict_devices",
+  ConflictDevice
+)
+  .fromDataset(conflictDevices)
+  .properties({ id: "id", name: "name", state: "state" })
+  .resolveConflicts({ strategy: "mostRecent", sourceTimestamp: "updated_at" })
 
-const ontology = new OntologyRegistry({ sources: [Device] })
+const ontology = new OntologyRegistry({ sources: [Device, ConflictDevice] })
 const projections = new ProjectionRegistry({
-  projections: [deviceProjection, temperatureProjection],
+  projections: [deviceProjection, temperatureProjection, conflictDeviceProjection],
   ontology,
   datasetsById: new Map<string, DatasetDefinition>([
     [devices.id, devices],
     [readings.id, readings],
+    [conflictDevices.id, conflictDevices],
   ]),
 })
 
@@ -339,6 +364,99 @@ export function runMaterializerStorageContractSuite<TStorage extends Storage>(
     }
   })
 
+  test(`${name} persists per-property Action edit times`, async () => {
+    const createdStorage = await provider.createStorage()
+    const storage = requireContractStorage(createdStorage)
+    let materializationOrdinal = 0
+    let now = new Date("2026-02-01T00:00:10.000Z")
+    const materializer = createOntologyMaterializer({
+      projectId: "materializer-storage-contract",
+      ontology,
+      projections,
+      storage,
+      dependencies: {
+        batching: { sourceStageRows: 1, statePageRows: 1, planChunkRows: 1 },
+        clock: () => now,
+        materializationId: () => `conflict-contract-candidate-${++materializationOrdinal}`,
+      },
+    })
+    const runtimeMaterializer = materializer.withScope(runtimeScope())
+    const ref = { objectTypeId: ConflictDevice.id, primaryId: "one" }
+    const replace = async (
+      versionId: string,
+      sourceUpdatedAt: string,
+      name: string,
+      state: string
+    ) => {
+      const datasetVersion = {
+        datasetId: conflictDevices.id,
+        versionId,
+        createdAt: sourceUpdatedAt,
+      }
+      const execution = await claim(storage, {
+        runId: `conflict-${versionId}`,
+        projectionId: conflictDeviceProjection.id,
+        protocol: "replacement",
+        datasetVersion,
+      })
+      const projectionMaterializerForRun = await projectionMaterializer(
+        materializer,
+        storage,
+        conflictDeviceProjection.id,
+        `conflict-${versionId}`
+      )
+      await projectionMaterializerForRun.projections.replace({
+        source: { projectionId: conflictDeviceProjection.id },
+        datasetVersion,
+        execution,
+        entries: entries([
+          {
+            root: { kind: "object", ref },
+            assertions: [{ kind: "object", ref, properties: { name, state }, sourceUpdatedAt }],
+          },
+        ]),
+      })
+    }
+    const edit = (requestId: string, propertyId: "name" | "state", value: string) =>
+      runtimeMaterializer.edits.commit({
+        mode: "atomic",
+        source: { kind: "runtime", requestId },
+        operations: [
+          {
+            id: requestId,
+            kind: "object.patch",
+            ref,
+            set: { [propertyId]: value },
+            unset: [],
+            reset: [],
+          },
+        ],
+        expectedObjects: [],
+        expectedLinks: [],
+        expectedLinkScopes: [],
+      })
+
+    try {
+      await replace("v1", "2026-02-01T00:00:10.000Z", "Source A", "source-open")
+
+      now = new Date("2026-02-01T00:00:11.000Z")
+      await edit("conflict-name", "name", "Action B")
+      now = new Date("2026-02-01T00:00:13.000Z")
+      await edit("conflict-state", "state", "action-closed")
+
+      await replace("v2", "2026-02-01T00:00:12.000Z", "Source C", "source-changed")
+      expect(
+        await storage.objects.getByPrimaryId({
+          projectId: "materializer-storage-contract",
+          objectTypeId: ConflictDevice.id,
+          primaryId: "one",
+        })
+      ).toMatchObject({ properties: { id: "one", name: "Source C", state: "action-closed" } })
+    } finally {
+      await provider.cleanup?.(createdStorage)
+    }
+  })
+
   test(`${name} persists cardinality-one edit authority by scope`, async () => {
     const createdStorage = await provider.createStorage()
     const storage = requireContractStorage(createdStorage)

package/src/workers/queue-worker.ts

@@ -66,11 +66,16 @@ export abstract class QueueWorker<
       failureCodes: config.failureCodes,
       workerId: config.workerId,
       leaseMs: config.leaseMs ?? DEFAULT_LEASE_MS,
-      claimLimit: config.claimLimit ?? DEFAULT_CLAIM_LIMIT,
+      claimLimit: normalizeClaimLimit(config.claimLimit),
       idlePollMs: config.idlePollMs ?? DEFAULT_IDLE_POLL_MS,
     }
   }
 
+  /** Maximum jobs this worker process claims and executes at once. */
+  get concurrency(): number {
+    return this.config.claimLimit
+  }
+
   protected async run(signal: AbortSignal): Promise<void> {
     const inFlight = new Set<Promise<void>>()
     let runError: unknown = null
@@ -243,6 +248,14 @@ export abstract class QueueWorker<
   }
 }
 
+function normalizeClaimLimit(value: number | undefined): number {
+  const claimLimit = value ?? DEFAULT_CLAIM_LIMIT
+  if (!Number.isSafeInteger(claimLimit) || claimLimit < 1) {
+    throw new Error("[SixbQueueWorker] Worker concurrency must be a positive safe integer.")
+  }
+  return claimLimit
+}
+
 async function settleOrLog<TJob extends QueueJob, TFailureCode extends SixbErrorCode>(
   delivery: QueueDelivery<TJob, TFailureCode>,
   operation: string,

package/src/workflows/execution.ts

@@ -1,7 +1,9 @@
 import { canViewWorkflowIntervention, canViewWorkflowRun, isAllowed } from "../authorization"
 import type { AuthorizablePrincipal, ExecutionContext } from "../execution"
+import { resolveExecutionCosts } from "../runtime/ai-cost"
 import { resolveExecutionUsage } from "../runtime/ai-usage"
 import type { SixbRuntimeContext } from "../runtime/types"
+import type { AiCostSummary } from "../storage/ai-cost"
 import type { AiModelCallUsage } from "../storage/ai-usage"
 import type {
   ListWorkflowInterventionsInput,
@@ -61,6 +63,8 @@ export type ListWorkflowRunNodesInput = Omit<
 /** Execution-facing Agent node view derived from its run row and model-call ledger. */
 export interface WorkflowAgentNodeRunView extends Omit<WorkflowAgentNodeRunRecord, "execution"> {
   readonly usage?: AiModelCallUsage
+  /** Preferred valuation; omitted when there are no calls or cost storage is unavailable. */
+  readonly cost?: AiCostSummary
 }
 
 /** Execution-facing workflow node view with optional Agent execution details. */
@@ -226,29 +230,45 @@ async function attachWorkflowNodeViews(
   )
   if (agentExecutions.length === 0) return nodes
 
-  const usages = await resolveExecutionUsage({
-    storage: runtime.storage.aiUsage,
-    projectId: runtime.projectId,
-    executionIds: agentExecutions.map((execution) => execution.executionId),
-  })
-  const usageByExecutionId = new Map(
-    agentExecutions.map((execution, index) => [execution.executionId, usages[index]] as const)
+  const executionIds = agentExecutions.map((execution) => execution.executionId)
+  const [usages, costs] = await Promise.all([
+    resolveExecutionUsage({
+      storage: runtime.storage.aiUsage,
+      projectId: runtime.projectId,
+      executionIds,
+    }),
+    resolveExecutionCosts({
+      storage: runtime.storage.aiCosts,
+      projectId: runtime.projectId,
+      executionIds,
+    }),
+  ])
+  const accountingByExecutionId = new Map(
+    agentExecutions.map((execution, index) => [
+      execution.executionId,
+      { usage: usages[index], cost: costs[index] },
+    ])
   )
 
   return nodes.map((node, index) => {
     const execution = executions[index]
     if (!execution) return node
-    const usage = usageByExecutionId.get(execution.executionId)
+    const accounting = accountingByExecutionId.get(execution.executionId)
     return {
       ...node,
-      agentExecution: toWorkflowAgentNodeRunView(execution, usage),
+      agentExecution: toWorkflowAgentNodeRunView(
+        execution,
+        accounting?.usage,
+        accounting?.usage === undefined ? undefined : accounting.cost
+      ),
     }
   })
 }
 
 function toWorkflowAgentNodeRunView(
   execution: WorkflowAgentNodeRunRecord,
-  usage: AiModelCallUsage | undefined
+  usage: AiModelCallUsage | undefined,
+  cost: AiCostSummary | undefined
 ): WorkflowAgentNodeRunView {
   return {
     projectId: execution.projectId,
@@ -267,6 +287,7 @@ function toWorkflowAgentNodeRunView(
     startedAt: execution.startedAt,
     completedAt: execution.completedAt,
     ...(usage === undefined ? {} : { usage }),
+    ...(usage === undefined || cost === undefined ? {} : { cost }),
   }
 }