@sixb/core 0.1.8 → 0.1.9

package/src/storage/executions/types.ts

@@ -29,6 +29,8 @@ export interface ExecutionRecord {
   readonly id: string
   readonly projectId: string
   readonly requestedBy?: AuthorizablePrincipal
+  /** Requester memberships at admission, independent of current execution authority. */
+  readonly requesterGroupIds: readonly string[]
   readonly executor: DurableExecutionExecutor
   readonly source: DurableExecutionSource
   readonly correlationId: string
@@ -36,8 +38,10 @@ export interface ExecutionRecord {
   readonly createdAt: Date
 }
 
-/** Creation input; the storage boundary assigns the immutable creation timestamp. */
-export type CreateExecutionInput = Omit<ExecutionRecord, "createdAt">
+/** Storage captures root memberships or inherits the parent's snapshot when omitted. */
+export type CreateExecutionInput = Omit<ExecutionRecord, "createdAt" | "requesterGroupIds"> & {
+  readonly requesterGroupIds?: readonly string[]
+}
 
 /** Immutable execution ledger. Records can be created and read, never updated or deleted. */
 export interface ExecutionStorage {

package/src/storage/executions/validation.ts

@@ -1,4 +1,5 @@
 import { isDeepStrictEqual } from "node:util"
+import { normalizeRequesterGroupIds, snapshotRequesterGroupIds } from "../../auth/attribution"
 import type {
   AuthorizablePrincipal,
   AuthorizationRef,
@@ -25,6 +26,30 @@ export interface ExecutionValidationLookup {
   }): Promise<{ readonly grantId: string } | null>
 }
 
+/** Capture accounting attribution at the same storage boundary that admits the execution. */
+export async function prepareExecutionRecord(
+  input: CreateExecutionInput,
+  lookup: ExecutionValidationLookup
+): Promise<ExecutionRecord> {
+  let groups = input.requesterGroupIds
+  if (groups === undefined && input.source.type === "execution") {
+    const parent = await lookup.getExecution({
+      projectId: input.projectId,
+      id: input.source.executionId,
+    })
+    groups = parent?.requesterGroupIds
+  } else if (groups === undefined && input.requestedBy) {
+    groups = await snapshotRequesterGroupIds({
+      auth: lookup.auth,
+      projectId: input.projectId,
+      principal: input.requestedBy,
+    })
+  }
+  const record = normalizeExecutionRecord({ ...input, requesterGroupIds: groups ?? [] })
+  await validateExecutionRecordReferences(record, lookup)
+  return record
+}
+
 export function normalizeExecutionRecord(
   input: CreateExecutionInput,
   createdAt: Date = new Date()
@@ -32,6 +57,7 @@ export function normalizeExecutionRecord(
   const record: ExecutionRecord = {
     id: input.id,
     projectId: input.projectId,
+    requesterGroupIds: normalizeRequesterGroupIds(input.requesterGroupIds ?? []),
     ...(input.requestedBy === undefined ? {} : { requestedBy: structuredClone(input.requestedBy) }),
     executor: structuredClone(input.executor),
     source: structuredClone(input.source),
@@ -368,6 +394,12 @@ async function validateParent(
       `[Sixb] Child execution '${record.id}' must preserve its parent requested-by principal.`
     )
   }
+  if (!isDeepStrictEqual(parent.requesterGroupIds, record.requesterGroupIds)) {
+    throw new ExecutionStorageError(
+      "invalid_parent_execution",
+      `[Sixb] Child execution '${record.id}' must preserve its parent requester-group snapshot.`
+    )
+  }
   if (
     record.executor.type === "agent" &&
     isInheritedAgentAuthority(record.authorizationRef) &&

package/src/storage/in-memory/index.ts

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks"
 import { InMemoryActionRunStorage } from "../action-runs"
 import { type AgentStorage, InMemoryAgentStorage } from "../agents"
 import { type AiAccountingAttribution, type AiCostStorage, InMemoryAiCostStorage } from "../ai-cost"
+import { directModelCallAttribution } from "../ai-cost/attribution"
 import { type AiLimitStorage, InMemoryAiLimitStorage } from "../ai-limits"
 import { type AiUsageStorage, InMemoryAiUsageStorage } from "../ai-usage"
 import { type AuthStorage, InMemoryAuthStorage } from "../auth"
@@ -188,7 +189,21 @@ export class InMemoryStorage implements Storage {
       projectId: input.projectId,
       id: input.executionId,
     })
-    if (!execution || execution.executor.type !== "agent") return undefined
+    if (!execution) return undefined
+    if (execution.executor.type !== "agent") {
+      const executor = execution.executor
+      return directModelCallAttribution(
+        executor.type === "primitive" ? executor.kind : executor.type,
+        executor.type === "request"
+          ? executor.requestId
+          : executor.type === "primitive"
+            ? executor.runId
+            : null,
+        execution.authorizationRef.type === "trustedPrimitive"
+          ? execution.authorizationRef.primitive.id
+          : null
+      )
+    }
     const directRun = await this.agentStorage.runs.getById({
       projectId: input.projectId,
       id: execution.executor.runId,

package/src/storage/index.ts

@@ -51,11 +51,6 @@ export {
   ACTION_RUN_FAILURE_CODES,
   ACTION_RUN_PHASES,
   ActionRunError,
-  actionRunParamsEqual,
-  actionRunPhaseRecordsEqual,
-  actionSubjectsEqual,
-  canRequeueActionRunAfterEnqueueFailure,
-  finishActionRunPhase,
   InMemoryActionRunStorage,
   isTerminalActionRun,
 } from "./action-runs"
@@ -197,14 +192,7 @@ export type {
   SummarizeAiUsageExecutionInput,
   SummarizeAiUsageExecutionsInput,
 } from "./ai-usage"
-export {
-  AiUsageStorageError,
-  aggregateAiModelCallUsage,
-  assertAiUsageExecutionId,
-  InMemoryAiUsageStorage,
-  normalizeAiModelCallRecord,
-  normalizeAiModelCallUsage,
-} from "./ai-usage"
+export { AiUsageStorageError, aggregateAiModelCallUsage, InMemoryAiUsageStorage } from "./ai-usage"
 export type {
   AccessTokenRecord,
   AccessTokenSubjectType,
@@ -367,8 +355,6 @@ export type {
   FileUploadStrategy,
 } from "./file-upload-sessions"
 export {
-  createFileUploadId,
-  createUploadExpiresAt,
   DEFAULT_FILE_UPLOAD_SESSION_TTL_MS,
   DEFAULT_FILE_UPLOAD_TERMINAL_SESSION_TTL_MS,
   FileUploadSessionError,
@@ -584,7 +570,6 @@ export type {
   StartPipelineStepRunInput,
 } from "./pipeline-runs"
 export {
-  canRequeuePipelineRunAfterEnqueueFailure,
   InMemoryPipelineRunStorage,
   PIPELINE_RUN_FAILURE_CODES,
   PipelineRunError,
@@ -623,8 +608,6 @@ export {
   PROJECTION_RUN_FAILURE_CODES,
   PROJECTION_RUN_PROGRESS_KEYS,
   ProjectionRunError,
-  projectionRunObjectTypesVisible,
-  zeroProjectionRunProgress,
 } from "./projection-runs"
 export type {
   ListActiveRuleStatesInput,
@@ -675,12 +658,7 @@ export type {
   SyncRunStatus,
   SyncRunStorage,
 } from "./sync-runs"
-export {
-  canRequeueSyncRunAfterEnqueueFailure,
-  InMemorySyncRunStorage,
-  SYNC_RUN_FAILURE_CODES,
-  SyncRunError,
-} from "./sync-runs"
+export { InMemorySyncRunStorage, SYNC_RUN_FAILURE_CODES, SyncRunError } from "./sync-runs"
 export type {
   TimeseriesHistoryBatchInput,
   TimeseriesHistoryBatchResult,
@@ -688,11 +666,7 @@ export type {
   TimeseriesPoint,
   TimeseriesStorage,
 } from "./timeseries"
-export {
-  assertTransactionActive,
-  createTransactionStorageProxy,
-  throwNestedStorageTransaction,
-} from "./transaction"
+
 export type { Storage, StorageTransactionOptions } from "./types"
 export type {
   FinishWebhookRunInput,

package/src/storage/internal.ts

@@ -0,0 +1,20 @@
+/** Implementation exports for Sixb packages only. */
+
+export {
+  actionRunParamsEqual,
+  actionRunPhaseRecordsEqual,
+  actionSubjectsEqual,
+  canRequeueActionRunAfterEnqueueFailure,
+  finishActionRunPhase,
+} from "./action-runs/idempotency"
+export { assertAiUsageExecutionId, normalizeAiModelCallRecord } from "./ai-usage/record"
+export { normalizeAiModelCallUsage } from "./ai-usage/usage"
+export { createFileUploadId, createUploadExpiresAt } from "./file-upload-sessions/utils"
+export { canRequeuePipelineRunAfterEnqueueFailure } from "./pipeline-runs/idempotency"
+export { projectionRunObjectTypesVisible, zeroProjectionRunProgress } from "./projection-runs/types"
+export { canRequeueSyncRunAfterEnqueueFailure } from "./sync-runs/idempotency"
+export {
+  assertTransactionActive,
+  createTransactionStorageProxy,
+  throwNestedStorageTransaction,
+} from "./transaction"

package/src/storage/workflow-runs/in-memory.ts

@@ -1,4 +1,3 @@
-import { normalizeRequesterGroupIds } from "../../auth/attribution"
 import { parseSixbFailure } from "../../errors/internal"
 import type { SixbFailure } from "../../errors/types"
 import type { AgentRunFailureCode } from "../agents"
@@ -143,7 +142,6 @@ export class InMemoryWorkflowRunStorage implements WorkflowRunStorage {
       queuedAt,
       startedAt: queuedAt,
       attempt: 0,
-      requesterGroupIds: normalizeRequesterGroupIds(input.requesterGroupIds),
     }
 
     this.runs.set(key, cloneRecord(record))

package/src/storage/workflow-runs/types.ts

@@ -144,8 +144,6 @@ export interface WorkflowRunRecord {
   readonly startedAt: Date
   readonly finishedAt?: Date
   readonly error?: SixbFailure<WorkflowRunFailureCode>
-  /** Durable group memberships snapshotted when the workflow run was admitted. */
-  readonly requesterGroupIds: readonly string[]
   readonly attempt: number
   readonly execution?: WorkflowRunExecution
 }
@@ -181,7 +179,6 @@ export interface QueueWorkflowRunInput {
   readonly workflowId: string
   readonly input: WorkflowIOSnapshot
   readonly queuedAt?: Date
-  readonly requesterGroupIds: readonly string[]
 }
 
 export interface ReclaimWorkflowRunInput {

package/src/testing/action-execution.ts

@@ -10,6 +10,7 @@ export async function createTestActionExecution(
     readonly actionId: string
     readonly runId: string
     readonly executionId?: string
+    readonly requesterGroupIds?: readonly string[]
   }
 ): Promise<string> {
   const parentExecutionId = `test_request_execution:${input.runId}`
@@ -27,6 +28,7 @@ export async function createTestActionExecution(
   if (!parent) {
     await executions.create({
       id: parentExecutionId,
+      requesterGroupIds: input.requesterGroupIds ?? [],
       projectId: input.projectId,
       executor: { type: "request", requestId: `test_request:${input.runId}` },
       source: { type: "http", requestId: `test_request:${input.runId}` },
@@ -36,6 +38,7 @@ export async function createTestActionExecution(
   }
   await executions.create({
     id: executionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "execution", executionId: parentExecutionId },
@@ -49,13 +52,17 @@ export async function createTestActionExecution(
 /** Queue an Action run with the valid durable execution fixture required by every provider. */
 export async function queueTestActionRun(
   storage: Pick<Storage, "actionRuns" | "executions">,
-  input: Omit<QueueActionRunInput, "executionId">
+  input: Omit<QueueActionRunInput, "executionId"> & {
+    readonly requesterGroupIds?: readonly string[]
+  }
 ): Promise<ActionRunRecord> {
   if (!storage.actionRuns) throw new Error("Action run storage is not configured for this test.")
   const executionId = await createTestActionExecution(storage.executions, {
     projectId: input.projectId,
     actionId: input.actionId,
     runId: input.id,
+    requesterGroupIds: input.requesterGroupIds,
   })
-  return storage.actionRuns.queue({ ...input, executionId })
+  const { requesterGroupIds: _groups, ...run } = input
+  return storage.actionRuns.queue({ ...run, executionId })
 }

package/src/testing/agent-execution.ts

@@ -13,6 +13,7 @@ export async function createTestAgentExecution(
     readonly runId: string
     readonly executionId?: string
     readonly sourceExecutionId?: string
+    readonly requesterGroupIds?: readonly string[]
     /** Conversational runs inherit authority; workflow fixtures use managed authority. */
     readonly authority?: "managed" | "inherited"
   }
@@ -65,6 +66,7 @@ export async function createTestAgentExecution(
   if (!parent) {
     parent = await storage.executions.create({
       id: sourceExecutionId,
+      requesterGroupIds: input.requesterGroupIds ?? [],
       projectId: input.projectId,
       executor: { type: "request", requestId: `test_request:${input.runId}` },
       source: { type: "http", requestId: `test_request:${input.runId}` },
@@ -74,6 +76,7 @@ export async function createTestAgentExecution(
   }
   await storage.executions.create({
     id: executionId,
+    requesterGroupIds: parent.requesterGroupIds,
     projectId: input.projectId,
     executor: { type: "agent", runId: input.runId },
     source: { type: "execution", executionId: sourceExecutionId },

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

@@ -93,7 +93,6 @@ function runInput(overrides: Partial<TestRunInput> = {}): TestRunInput {
     triggerMessageId: "msg_user_1",
     spec: { model: { provider: "test", modelId: "large" } },
     executionId: "test_agent_execution:run_1",
-    requesterGroupIds: ["support", "engineering", "support"],
     execution: execution("exec_1"),
     createdAt: at("2026-06-23T10:00:10.000Z"),
     ...overrides,
@@ -491,7 +490,6 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
           spawnKey: "research-orders",
           status: "queued",
           attempt: 0,
-          requesterGroupIds: ["engineering", "support"],
           spec: input.spec,
         })
         expect(child).not.toHaveProperty("threadId")
@@ -655,7 +653,6 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
         const run = await createAndStartRun(storage, fixture, runInput({ id: "run_1" }))
         expect(run).toMatchObject({ status: "running", attempt: 1, threadId: "thr_1" })
         expect(run.executionId).toBe("test_agent_execution:run_1")
-        expect(run.requesterGroupIds).toEqual(["engineering", "support"])
         expect(run.execution?.token).toBe("exec_1")
         await expect(storage.threads.getById({ projectId, id: "thr_1" })).resolves.toMatchObject({
           activeRunId: "run_1",
@@ -791,10 +788,8 @@ export function runAgentStorageContractSuite<TStorage extends AgentStorageContra
           mutableExecution.token = "mutated"
           mutableExecution.queueLeaseExpiresAt.setTime(0)
         }
-        ;(run.requesterGroupIds as string[]).push("mutated")
         const reread = await storage.runs.getById({ projectId, id: "run_1" })
         expect(reread?.execution?.token).toBe("exec_1")
-        expect(reread?.requesterGroupIds).toEqual(["engineering", "support"])
       })
     })
 

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

@@ -22,6 +22,80 @@ export function runAiModelCallGroupsContractSuite<T extends AiModelCallGroupsCon
   options: AiStorageContractSuiteOptions<T>
 ): void {
   describe(name, () => {
+    test("attributes direct calls and retries to requests, actions, and workflows", async () => {
+      // Removal proof: return undefined from directModelCallAttribution and run this suite.
+      const storage = await options.createStorage()
+      try {
+        await options.setup?.(storage)
+        const expected = [
+          { kind: "request", requestId: "request" },
+          { kind: "action", actionId: "summarize", actionRunId: "action" },
+          { kind: "workflow", workflowId: "summarize", workflowRunId: "workflow" },
+        ] as const
+        for (const attribution of expected) {
+          const kind = attribution.kind
+          const primitive = {
+            kind: kind === "action" ? ("action" as const) : ("workflow" as const),
+            id: "summarize",
+            runId: kind,
+          }
+          const execution = await storage.executions.create({
+            projectId,
+            id: kind,
+            executor:
+              kind === "request"
+                ? { type: "request", requestId: kind }
+                : { type: "primitive", kind, runId: kind },
+            source:
+              kind === "request"
+                ? { type: "http", requestId: kind }
+                : { type: "event", eventId: kind },
+            correlationId: kind,
+            authorizationRef:
+              kind === "request" ? { type: "disabled" } : { type: "trustedPrimitive", primitive },
+          })
+          for (const attempt of [1, 2]) {
+            await storage.aiUsage.recordModelCall({
+              projectId,
+              id: `${kind}:${attempt}`,
+              executionId: execution.id,
+              attempt,
+              callId: `${kind}:${attempt}`,
+              requesterGroupIds: execution.requesterGroupIds,
+              providerId: "test",
+              requestedModelId: "small",
+              responseId: `${kind}:${attempt}`,
+              usage: { inputTokens: 2, outputTokens: 3 },
+              occurredAt: new Date("2026-09-01T12:00:00Z"),
+            })
+          }
+          const calls = await storage.aiCosts.listModelCalls({
+            ...range,
+            executionId: execution.id,
+          })
+          expect(calls.total).toBe(2)
+          expect(calls.items.map((call) => call.attribution)).toEqual([attribution, attribution])
+        }
+        const groups = await storage.aiCosts.listModelCallGroups(range)
+        expect(groups.total).toBe(3)
+        for (const attribution of expected) {
+          const group = groups.items.find((item) => item.executionId === attribution.kind)
+          expect(group).toMatchObject({
+            attribution,
+            modelCallCount: 2,
+            totalTokens: 10,
+            executions: [{ attribution, modelCallCount: 2 }],
+          })
+        }
+        const overview = await storage.aiCosts.queryProjectOverview({ ...range, bucket: "day" })
+        expect(overview.totals.modelCallCount).toBe(6)
+        expect(overview.agents).toEqual([])
+        expect(overview.workflows).toMatchObject([{ workflowId: "summarize", modelCallCount: 2 }])
+      } 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 {
@@ -195,7 +269,6 @@ async function seedWorkflowCall(
     workflowId,
     executionId: sourceExecutionId,
     input: {},
-    requesterGroupIds: [],
   })
   await storage.workflowRuns.start({ projectId, id: runId })
   const nodeRunId = `${runId}:node:0`
@@ -275,7 +348,6 @@ async function seed(storage: AiModelCallGroupsContractStorage) {
       threadId: "thread",
       triggerMessageId: `message_${runId}`,
       spec: { model: { provider: "parent-provider", modelId: "large" } },
-      requesterGroupIds: [],
     })
     await storage.agents.runs.start({
       id: runId,

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

@@ -43,6 +43,56 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
   }
 
   describe(label, () => {
+    test("captures memberships once and inherits them independently of current authority", async () => {
+      // Removal proof: skip prepareExecutionRecord's membership capture or parent inheritance.
+      await withStorage(async (storage) => {
+        await seedAuth(storage.auth)
+        for (const groupId of ["support", "finance"]) {
+          await storage.auth.groupMemberships.upsert({
+            projectId,
+            userId: "user-one",
+            groupId,
+            source: "manual",
+          })
+        }
+        const parent = await storage.executions.create({
+          ...principalRequest({ id: "parent" }),
+          requesterGroupIds: undefined,
+        })
+        expect(parent.requesterGroupIds).toEqual(["finance", "support"])
+        await storage.auth.groupMemberships.remove({
+          projectId,
+          userId: "user-one",
+          groupId: "finance",
+        })
+        const childInput = trustedPrimitive("child", {
+          source: { type: "execution", executionId: parent.id },
+          correlationId: parent.correlationId,
+        })
+        const child = await storage.executions.create({
+          ...childInput,
+          requesterGroupIds: undefined,
+        })
+        expect(child.requesterGroupIds).toEqual(["finance", "support"])
+        ;(child.requesterGroupIds as string[]).push("mutated")
+        await expect(
+          storage.executions.getById({ projectId, id: child.id })
+        ).resolves.toMatchObject({ requesterGroupIds: ["finance", "support"] })
+        await expect(
+          storage.executions.create({
+            ...childInput,
+            id: "wrong-groups",
+            requesterGroupIds: ["support"],
+          })
+        ).rejects.toMatchObject({ code: "invalid_parent_execution" })
+        const next = await storage.executions.create({
+          ...principalRequest({ id: "next" }),
+          requesterGroupIds: undefined,
+        })
+        expect(next.requesterGroupIds).toEqual(["support"])
+      })
+    })
+
     test("round-trips every durable executor and authority shape", async () => {
       await withStorage(async (storage) => {
         await seedAuth(storage.auth)
@@ -69,7 +119,10 @@ export function runExecutionStorageContractSuite<TStorage extends ExecutionStora
           const creationStartedAt = new Date()
           const created = await storage.executions.create(input)
           const { createdAt: persistedAt, ...persistedInput } = created
-          expect(persistedInput).toEqual(input)
+          expect(persistedInput).toEqual({
+            ...input,
+            requesterGroupIds: input.requesterGroupIds ?? [],
+          })
           expect(Number.isFinite(persistedAt.getTime())).toBe(true)
           expect(persistedAt.getTime()).toBeGreaterThanOrEqual(creationStartedAt.getTime())
           expect(
@@ -395,6 +448,7 @@ function principalRequest(input: {
     id: input.id,
     projectId,
     requestedBy: principal,
+    requesterGroupIds: [],
     executor: { type: "request", requestId: `request-${input.id}` },
     source: { type: "http", requestId: `request-${input.id}` },
     correlationId: input.id === "parent" ? "correlation-parent" : `correlation-${input.id}`,
@@ -410,6 +464,7 @@ function disabledRequest(id: string, inputProjectId = projectId): CreateExecutio
   return {
     id,
     projectId: inputProjectId,
+    requesterGroupIds: [],
     executor: { type: "request", requestId: `request-${id}` },
     source: { type: "http", requestId: `request-${id}` },
     correlationId: `correlation-${id}`,
@@ -445,6 +500,7 @@ function trustedPrimitive(
     id,
     projectId,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "primitive", kind, runId },
     source: trustedPrimitiveSource(kind, id),
     correlationId: `correlation-${id}`,
@@ -491,6 +547,7 @@ function agentExecution(id: string): CreateExecutionInput {
     id,
     projectId,
     requestedBy: { type: "user", id: "user-one" },
+    requesterGroupIds: [],
     executor: { type: "agent", runId: `run-${id}` },
     source: { type: "execution", executionId: "principal-request" },
     correlationId: "correlation-principal-request",
@@ -507,6 +564,7 @@ function kernelExecution(id: string): CreateExecutionInput {
     id,
     projectId,
     executor: { type: "kernel", operation },
+    requesterGroupIds: [],
     source: { type: "event", eventId: `event-${id}` },
     correlationId: `correlation-${id}`,
     authorizationRef: { type: "kernel", operation },

package/src/testing/execution.ts

@@ -1,6 +1,7 @@
 import type { AuthorizationContext } from "../authorization"
 import { createTestingScope } from "../execution/scopes"
 import type { ExecutionScope } from "../execution/types"
+import { bindModelExecutionAttempt } from "../models/execution/binding"
 import type { OntologySource } from "../ontology"
 import { SixbHost, type SixbHostOptions } from "../runtime/host"
 import { isBoundSixb, type Sixb } from "../runtime/sixb"
@@ -8,6 +9,7 @@ import { isBoundSixb, type Sixb } from "../runtime/sixb"
 export type { AuthorizationContext } from "../authorization"
 
 export interface TestExecutionOptions {
+  readonly signal?: AbortSignal
   readonly authorization?: AuthorizationContext
   readonly executionId?: string
   readonly requestId?: string
@@ -44,5 +46,9 @@ export function createTestSixb<
   if (!isBoundSixb<TOntologySources>(sixb)) {
     throw new Error("[Sixb] Test host did not return an execution-bound Sixb SDK.")
   }
+  bindModelExecutionAttempt(sixb.models, {
+    attempt: 1,
+    signal: options.signal ?? new AbortController().signal,
+  })
   return sixb
 }

package/src/testing/workflow-execution.ts

@@ -10,6 +10,7 @@ export async function createTestWorkflowExecution(
     readonly runId: string
     readonly executionId?: string
     readonly requestedBy?: AuthorizablePrincipal
+    readonly requesterGroupIds?: readonly string[]
   }
 ): Promise<string> {
   const parentExecutionId = `test_request_execution:${input.runId}`
@@ -22,6 +23,7 @@ export async function createTestWorkflowExecution(
 
   await executions.create({
     id: parentExecutionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "request", requestId: `test_request:${input.runId}` },
     source: { type: "http", requestId: `test_request:${input.runId}` },
@@ -34,6 +36,7 @@ export async function createTestWorkflowExecution(
   })
   await executions.create({
     id: executionId,
+    requesterGroupIds: input.requesterGroupIds ?? [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: { type: "execution", executionId: parentExecutionId },
@@ -66,6 +69,7 @@ export async function createTestAutomaticWorkflowExecution(
 
   await executions.create({
     id: executionId,
+    requesterGroupIds: [],
     projectId: input.projectId,
     executor: { type: "primitive", kind: primitive.kind, runId: primitive.runId },
     source: input.source ?? { type: "event", eventId: `test_event:${input.runId}` },