@sixb/core 0.1.6 → 0.1.8

package/src/storage/share-sessions/record.ts

@@ -0,0 +1,176 @@
+import { ShareSessionStorageError } from "./errors"
+import type {
+  CreateShareSessionInput,
+  GetShareSessionByIdInput,
+  RenewShareSessionIfValidInput,
+  RevokeShareSessionInput,
+  ShareSessionRecord,
+} from "./types"
+
+const SHA256_HEX = /^[0-9a-f]{64}$/
+
+export function normalizeShareSessionCreate(input: CreateShareSessionInput): ShareSessionRecord {
+  if (!isRecord(input)) throw invalidInput("Share session create input must be an object.")
+  const createdAt = inputDate(input.createdAt, "Share session creation time")
+  const expiresAt = inputDate(input.expiresAt, "Share session inactivity expiry")
+  const absoluteExpiresAt = inputDate(input.absoluteExpiresAt, "Share session absolute expiry")
+  if (expiresAt.getTime() <= createdAt.getTime()) {
+    throw invalidInput("Share session inactivity expiry must be later than creation time.")
+  }
+  if (absoluteExpiresAt.getTime() <= createdAt.getTime()) {
+    throw invalidInput("Share session absolute expiry must be later than creation time.")
+  }
+  if (expiresAt.getTime() > absoluteExpiresAt.getTime()) {
+    throw invalidInput("Share session inactivity expiry must not exceed its absolute expiry.")
+  }
+
+  return {
+    id: identifier(input.id, "Share session id"),
+    projectId: identifier(input.projectId, "Project id"),
+    grantId: identifier(input.grantId, "Share grant id"),
+    tokenHash: sha256(input.tokenHash, "Share session token hash"),
+    createdAt,
+    expiresAt,
+    absoluteExpiresAt,
+  }
+}
+
+export function parseShareSessionRecord(input: unknown): ShareSessionRecord {
+  if (!isRecord(input)) throw invalidRecord("Share session row must be an object.")
+  try {
+    const createdAt = storedDate(input.createdAt, "Share session creation time")
+    const expiresAt = storedDate(input.expiresAt, "Share session inactivity expiry")
+    const absoluteExpiresAt = storedDate(input.absoluteExpiresAt, "Share session absolute expiry")
+    if (expiresAt.getTime() <= createdAt.getTime()) {
+      throw invalidRecord("Share session inactivity expiry must be later than creation time.")
+    }
+    if (absoluteExpiresAt.getTime() <= createdAt.getTime()) {
+      throw invalidRecord("Share session absolute expiry must be later than creation time.")
+    }
+    if (expiresAt.getTime() > absoluteExpiresAt.getTime()) {
+      throw invalidRecord("Share session inactivity expiry exceeds its absolute expiry.")
+    }
+
+    const revokedAtValue = input.revokedAt
+    if (revokedAtValue === null) {
+      throw invalidRecord("Share session revocation time must be omitted rather than null.")
+    }
+    const revokedAt =
+      revokedAtValue === undefined
+        ? undefined
+        : storedDate(revokedAtValue, "Share session revocation time")
+    if (revokedAt && revokedAt.getTime() < createdAt.getTime()) {
+      throw invalidRecord("Share session revocation time must not precede creation time.")
+    }
+
+    return {
+      id: identifier(input.id, "Share session id"),
+      projectId: identifier(input.projectId, "Project id"),
+      grantId: identifier(input.grantId, "Share grant id"),
+      tokenHash: sha256(input.tokenHash, "Share session token hash"),
+      createdAt,
+      expiresAt,
+      absoluteExpiresAt,
+      ...(revokedAt === undefined ? {} : { revokedAt }),
+    }
+  } catch (error) {
+    if (error instanceof ShareSessionStorageError) {
+      if (error.code === "invalid_record") throw error
+      throw invalidRecord(error.message.replace(/^\[Sixb\] /, ""), error)
+    }
+    throw error
+  }
+}
+
+export function normalizeGetShareSessionByIdInput(
+  input: GetShareSessionByIdInput
+): GetShareSessionByIdInput {
+  if (!isRecord(input)) throw invalidInput("Share session lookup input must be an object.")
+  return {
+    projectId: identifier(input.projectId, "Project id"),
+    id: identifier(input.id, "Share session id"),
+  }
+}
+
+export function normalizeRenewShareSessionIfValidInput(
+  input: RenewShareSessionIfValidInput
+): RenewShareSessionIfValidInput {
+  if (!isRecord(input)) throw invalidInput("Share session renewal input must be an object.")
+  const now = inputDate(input.now, "Share session renewal time")
+  const expiresAt = inputDate(input.expiresAt, "Requested Share session expiry")
+  if (expiresAt.getTime() <= now.getTime()) {
+    throw invalidInput("Requested Share session expiry must be later than renewal time.")
+  }
+  return {
+    projectId: identifier(input.projectId, "Project id"),
+    id: identifier(input.id, "Share session id"),
+    grantId: identifier(input.grantId, "Share grant id"),
+    tokenHash: sha256(input.tokenHash, "Share session token hash"),
+    now,
+    expiresAt,
+  }
+}
+
+export function normalizeRevokeShareSessionInput(
+  input: RevokeShareSessionInput,
+  createdAt?: Date
+): RevokeShareSessionInput {
+  if (!isRecord(input)) throw invalidInput("Share session revocation input must be an object.")
+  const normalized = {
+    projectId: identifier(input.projectId, "Project id"),
+    id: identifier(input.id, "Share session id"),
+    revokedAt: inputDate(input.revokedAt, "Share session revocation time"),
+  }
+  if (createdAt && normalized.revokedAt.getTime() < createdAt.getTime()) {
+    throw invalidInput("Share session revocation time must not precede creation time.")
+  }
+  return normalized
+}
+
+export function cloneShareSessionRecord(input: ShareSessionRecord): ShareSessionRecord {
+  return structuredClone(input)
+}
+
+function identifier(value: unknown, label: string): string {
+  if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
+    throw invalidInput(`${label} must be a non-empty string without NUL bytes.`)
+  }
+  return value
+}
+
+function sha256(value: unknown, label: string): string {
+  if (typeof value !== "string" || !SHA256_HEX.test(value)) {
+    throw invalidInput(`${label} must be a lowercase SHA-256 hex digest.`)
+  }
+  return value
+}
+
+function inputDate(value: unknown, label: string): Date {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw invalidInput(`${label} must be a valid Date.`)
+  }
+  return new Date(value)
+}
+
+function storedDate(value: unknown, label: string): Date {
+  const parsed =
+    value instanceof Date
+      ? new Date(value)
+      : typeof value === "string"
+        ? new Date(value)
+        : new Date(Number.NaN)
+  if (!Number.isFinite(parsed.getTime())) throw invalidRecord(`${label} is invalid.`)
+  return parsed
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function invalidInput(message: string, cause?: unknown): ShareSessionStorageError {
+  return new ShareSessionStorageError("invalid_input", `[Sixb] ${message}`, { cause })
+}
+
+function invalidRecord(message: string, cause?: unknown): ShareSessionStorageError {
+  return new ShareSessionStorageError("invalid_record", `[Sixb] ${message}`, { cause })
+}

package/src/storage/share-sessions/types.ts

@@ -0,0 +1,57 @@
+/** Durable server-side session created after a Share link secret is exchanged. */
+export interface ShareSessionRecord {
+  readonly id: string
+  readonly projectId: string
+  readonly grantId: string
+  /** SHA-256 of the bearer session secret. The plaintext secret is never durable. */
+  readonly tokenHash: string
+  readonly createdAt: Date
+  /** Sliding inactivity deadline. */
+  readonly expiresAt: Date
+  /** Immutable upper bound, normally inherited from the Share grant expiry. */
+  readonly absoluteExpiresAt: Date
+  readonly revokedAt?: Date
+}
+
+export type CreateShareSessionInput = Omit<ShareSessionRecord, "revokedAt">
+
+export interface GetShareSessionByIdInput {
+  readonly projectId: string
+  readonly id: string
+}
+
+export interface RenewShareSessionIfValidInput {
+  readonly projectId: string
+  readonly id: string
+  readonly grantId: string
+  readonly tokenHash: string
+  /** Explicit clock keeps expiry semantics deterministic across providers. */
+  readonly now: Date
+  /** Requested sliding inactivity deadline. Storage clamps it to the absolute deadline. */
+  readonly expiresAt: Date
+}
+
+export interface RevokeShareSessionInput {
+  readonly projectId: string
+  readonly id: string
+  readonly revokedAt: Date
+}
+
+/** Persistence contract for short-lived Share access sessions. */
+export interface ShareSessionStorage {
+  /** `(projectId, id)` and `(projectId, tokenHash)` must both be unique. */
+  create(input: CreateShareSessionInput): Promise<ShareSessionRecord>
+
+  /** Load one project-scoped session, including expired or revoked sessions, or return null. */
+  getById(input: GetShareSessionByIdInput): Promise<ShareSessionRecord | null>
+
+  /**
+   * Atomically authenticate and renew an active session. Mismatched, expired, or revoked sessions
+   * return null. A renewal never shortens the current deadline and never exceeds
+   * `absoluteExpiresAt`.
+   */
+  renewIfValid(input: RenewShareSessionIfValidInput): Promise<ShareSessionRecord | null>
+
+  /** Preserve and return the first revocation; a missing session returns null. */
+  revoke(input: RevokeShareSessionInput): Promise<ShareSessionRecord | null>
+}

package/src/storage/transaction.ts

@@ -1,12 +1,21 @@
 import { StorageTransactionError } from "./errors"
+import { createObjectOperationScope } from "./operation-scope"
+import type { Storage } from "./types"
 
 type ObjectLike = Record<PropertyKey, unknown>
 
-export function createTransactionStorageProxy<T extends object>(
+export function createTransactionStorageProxy<T extends Storage>(
   target: T,
   isActive: () => boolean
 ): T {
   const proxies = new WeakMap<object, object>()
+  const objectStorage = createObjectOperationScope(target.objects, {
+    assertAvailable: () => assertTransactionActive(isActive),
+    run: async <TResult>(operation: () => Promise<TResult> | TResult): Promise<TResult> => {
+      assertTransactionActive(isActive)
+      return operation()
+    },
+  })
 
   const wrap = <TValue extends object>(value: TValue): TValue => {
     const existing = proxies.get(value)
@@ -19,7 +28,10 @@ export function createTransactionStorageProxy<T extends object>(
       // from `tx` are wrapped (a handful), not the row/link data graph, and never per-record.
       get(current, property, receiver) {
         assertTransactionActive(isActive)
-        const result = Reflect.get(current, property, receiver)
+        const result =
+          current === target && property === "objects"
+            ? objectStorage
+            : Reflect.get(current, property, receiver)
         if (typeof result === "function") {
           return (...args: unknown[]) => {
             assertTransactionActive(isActive)

package/src/storage/types.ts

@@ -1,6 +1,7 @@
 import type { ActionRunStorage } from "./action-runs"
 import type { AgentStorage } from "./agents"
 import type { AiCostStorage } from "./ai-cost"
+import type { AiLimitStorage } from "./ai-limits"
 import type { AiUsageStorage } from "./ai-usage"
 import type { AuthStorage } from "./auth"
 import type { ConnectorConnectionStorage } from "./connector-connections"
@@ -11,6 +12,8 @@ import type { OntologyStorage } from "./ontology"
 import type { PipelineRunStorage } from "./pipeline-runs"
 import type { ProjectionRunStorage } from "./projection-runs"
 import type { RulesStorage } from "./rules"
+import type { ShareGrantStorage } from "./share-grants"
+import type { ShareSessionStorage } from "./share-sessions"
 import type { SyncRunStorage } from "./sync-runs"
 import type { TimeseriesStorage } from "./timeseries/types"
 import type { WebhookRunStorage } from "./webhook-runs"
@@ -43,13 +46,17 @@ export type {
   AgentMessageRecord,
   AgentRunExecution,
   AgentRunFailureCode,
+  AgentRunKind,
   AgentRunRecord,
   AgentStorage,
   AgentThreadRecord,
   AppendAgentMessageInput,
   ConfirmAgentRunExecutionOwnershipInput,
+  ConversationAgentRunRecord,
+  ConversationAgentRunSpec,
   CreateAgentRunInput,
   CreateAgentThreadInput,
+  CreateSubagentRunInput,
   FinishAgentRunInput,
   FinishQueuedAgentRunInput,
   ListAgentMessagesInput,
@@ -60,8 +67,39 @@ export type {
   ListAgentThreadsResult,
   ReclaimAgentRunInput,
   StartAgentRunInput,
+  SubagentRunRecord,
+  SubagentRunResult,
+  SubagentRunSpec,
 } from "./agents"
 export { AGENT_RUN_FAILURE_CODES, AgentStorageError } from "./agents"
+export type {
+  AiLimitConsumption,
+  AiLimitMeter,
+  AiLimitPeriod,
+  AiLimitPeriodKind,
+  AiLimitPolicy,
+  AiLimitPolicyStatus,
+  AiLimitQuantity,
+  AiLimitReservationBucket,
+  AiLimitStorage,
+  AiLimitStorageErrorCode,
+  AiLimitSubject,
+  AiModelCallReservation,
+  AiModelCallReservationIdentity,
+  AiModelCallReservationState,
+  CreateAiLimitPolicyInput,
+  DeleteAiLimitPolicyInput,
+  GetAiLimitPolicyInput,
+  ListAiLimitPoliciesInput,
+  ListAiLimitPolicyStatusesInput,
+  MarkAiModelCallReservationUnknownInput,
+  ReconcileAiModelCallInput,
+  RecordAiModelCallLimitActualsInput,
+  ReserveAiModelCallInput,
+  ReserveAiModelCallResult,
+  UpdateAiLimitPolicyInput,
+} from "./ai-limits"
+export { AiLimitStorageError, aiLimitCalendarMonth } from "./ai-limits"
 export type {
   AiModelCallUsage,
   AiModelCallUsageInput,
@@ -195,6 +233,29 @@ export type {
   RuleStateRecord,
   RulesStorage,
 } from "./rules"
+export type {
+  CreateShareGrantInput,
+  GetShareGrantByIdInput,
+  ListShareGrantsInput,
+  ListShareGrantsResult,
+  RevokeShareGrantInput,
+  ShareAuthoritySnapshot,
+  ShareAuthoritySnapshotV1,
+  ShareGrantRecord,
+  ShareGrantStorage,
+  ShareGrantStorageErrorCode,
+} from "./share-grants"
+export { ShareGrantStorageError } from "./share-grants"
+export type {
+  CreateShareSessionInput,
+  GetShareSessionByIdInput,
+  RenewShareSessionIfValidInput,
+  RevokeShareSessionInput,
+  ShareSessionRecord,
+  ShareSessionStorage,
+  ShareSessionStorageErrorCode,
+} from "./share-sessions"
+export { ShareSessionStorageError } from "./share-sessions"
 export type {
   FinishSyncRunInput,
   ListSyncRunsInput,
@@ -295,6 +356,7 @@ export interface Storage {
   agents?: AgentStorage
   aiUsage?: AiUsageStorage
   aiCosts?: AiCostStorage
+  aiLimits?: AiLimitStorage
   actionRuns?: ActionRunStorage
   syncRuns?: SyncRunStorage
   pipelineRuns?: PipelineRunStorage
@@ -303,6 +365,8 @@ export interface Storage {
   workflowInterventions?: WorkflowInterventionStorage
   webhookRuns?: WebhookRunStorage
   rules?: RulesStorage
+  shareGrants?: ShareGrantStorage
+  shareSessions?: ShareSessionStorage
   fileUploadSessions?: FileUploadSessionStore
   connectorConnections?: ConnectorConnectionStorage
 

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

@@ -628,7 +628,7 @@ export class InMemoryWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRun
       projectId: input.projectId,
       executionId: input.executionId,
       nodeRunId: input.nodeRunId,
-      agentId: input.agentId,
+      actorId: input.actorId,
       workflowExecutionId: workflowRun.executionId,
     })
     if (node.status !== "running") {
@@ -655,7 +655,7 @@ export class InMemoryWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRun
       projectId: input.projectId,
       nodeRunId: input.nodeRunId,
       executionId: input.executionId,
-      agentId: input.agentId,
+      actorId: input.actorId,
       status: "queued",
       prompt: input.prompt,
       attempt: 0,
@@ -747,7 +747,7 @@ export class InMemoryWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRun
     const order = input.order ?? "desc"
     const filtered = [...this.runs.values()]
       .filter((run) => run.projectId === input.projectId)
-      .filter((run) => (input.agentId ? run.agentId === input.agentId : true))
+      .filter((run) => (input.actorId ? run.actorId === input.actorId : true))
       .filter((run) => (statuses ? statuses.has(run.status) : true))
       .sort((a, b) =>
         order === "asc"

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

@@ -42,7 +42,7 @@ export async function assertWorkflowAgentNodeRunExecution(input: {
   readonly projectId: string
   readonly executionId: string
   readonly nodeRunId: string
-  readonly agentId: string
+  readonly actorId: string
   readonly workflowExecutionId: string
 }): Promise<void> {
   const execution = await findAgentRunExecution({
@@ -50,7 +50,7 @@ export async function assertWorkflowAgentNodeRunExecution(input: {
     projectId: input.projectId,
     executionId: input.executionId,
     runId: input.nodeRunId,
-    serviceAccountId: agentServiceAccountId(input.agentId),
+    authority: { type: "managed", serviceAccountId: agentServiceAccountId(input.actorId) },
   })
   if (
     !execution ||

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

@@ -21,6 +21,8 @@ export const WORKFLOW_RUN_FAILURE_CODES = [
   "internal.unexpected",
   "runtime.cancelled",
   "workflow.node_failed",
+  "ai.usage_limit_exceeded",
+  "ai.usage_limit_unavailable",
 ] as const satisfies readonly [SixbErrorCode, ...SixbErrorCode[]]
 
 export type WorkflowRunFailureCode = (typeof WORKFLOW_RUN_FAILURE_CODES)[number]
@@ -42,7 +44,8 @@ export interface WorkflowAgentNodeRunRecord {
   readonly projectId: string
   readonly nodeRunId: string
   readonly executionId: string
-  readonly agentId: string
+  /** Stable managed actor for the workflow + Agent step, not the step definition id. */
+  readonly actorId: string
   readonly status: WorkflowAgentNodeRunStatus
   readonly prompt: string
   readonly modelId?: string
@@ -61,7 +64,7 @@ export interface CreateWorkflowAgentNodeRunInput {
   readonly projectId: string
   readonly nodeRunId: string
   readonly executionId: string
-  readonly agentId: string
+  readonly actorId: string
   readonly prompt: string
   readonly createdAt?: Date
 }
@@ -116,7 +119,7 @@ export interface CancelWorkflowAgentNodeRunInput {
 
 export interface ListWorkflowAgentNodeRunsInput {
   readonly projectId: string
-  readonly agentId?: string
+  readonly actorId?: string
   readonly statuses?: readonly WorkflowAgentNodeRunStatus[]
   readonly limit?: number
   readonly offset?: number

package/src/syncs/execution.ts

@@ -1,5 +1,6 @@
-import { isAllowed } from "../authorization"
+import { assertAuthorized, isRuntimeAllowed } from "../authorization"
 import type { ExecutionContext } from "../execution"
+import { resolveRuntimeAuthorizationForProject } from "../execution/authorization"
 import type { SixbRuntimeContext } from "../runtime/types"
 import type {
   ListLatestSyncRunsResult,
@@ -29,26 +30,39 @@ export function createSyncsRuntime(
   execution: ExecutionContext,
   source: Pick<SyncsRuntime, "list" | "getById">
 ): SyncsRuntime {
-  const allowed = (syncId: string) => isAllowed(runtime.authorization, { kind: "sync.run", syncId })
+  const authority = resolveRuntimeAuthorizationForProject(runtime)
+  const allowed = (syncId: string) => isRuntimeAllowed(runtime, { kind: "sync.run", syncId })
   const visibleIds = () =>
     source
       .list()
       .filter((sync) => allowed(sync.id))
       .map((sync) => sync.id)
+  const historyFilterIds = () =>
+    authority.type === "unrestricted"
+      ? undefined
+      : authority.type === "principal"
+        ? visibleIds()
+        : []
 
   return {
-    list: () => source.list().filter((sync) => allowed(sync.id)),
+    list: () =>
+      authority.type === "denied" || authority.type === "delegated"
+        ? []
+        : source.list().filter((sync) => allowed(sync.id)),
     getById: (syncId) => {
+      if (authority.type === "denied" || authority.type === "delegated") return null
       const sync = source.getById(syncId)
       return sync && allowed(syncId) ? sync : null
     },
     request: async (input) => {
+      assertAuthorized(runtime, { kind: "sync.run", syncId: input.syncId })
       const sync = source.getById(input.syncId)
       if (!sync) throw new SyncValidationError(`[Sixb] Unknown sync '${input.syncId}'`)
       return requestSyncRun(runtime, execution, sync, input)
     },
     runs: {
       getById: async (runId) => {
+        if (authority.type === "denied" || authority.type === "delegated") return null
         const run =
           (await runtime.storage.syncRuns?.getById({
             projectId: runtime.projectId,
@@ -57,15 +71,21 @@ export function createSyncsRuntime(
         return run && allowed(run.syncId) ? run : null
       },
       list: (input = {}) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ runs: [], hasMore: false, total: 0 })
+        }
         const storage = runtime.storage.syncRuns
         if (!storage) return Promise.resolve({ runs: [], hasMore: false, total: 0 })
         return storage.list({
-          projectId: runtime.projectId,
           ...input,
-          syncIds: runtime.authorization ? visibleIds() : undefined,
+          syncIds: historyFilterIds(),
+          projectId: runtime.projectId,
         })
       },
       listLatest: (syncIds) => {
+        if (authority.type === "denied" || authority.type === "delegated") {
+          return Promise.resolve({ runs: [] })
+        }
         const storage = runtime.storage.syncRuns
         if (!storage || syncIds.length === 0) return Promise.resolve({ runs: [] })
         const allowedIds = syncIds.filter(allowed)

package/src/syncs/request.ts

@@ -1,4 +1,5 @@
 import { assertAuthorized } from "../authorization"
+import { resolveExecutionScopeAuthorization } from "../execution/authorization"
 import {
   createPrimitiveExecutionRecord,
   ensureExecutionRecord,
@@ -45,6 +46,10 @@ export async function requestSyncRun(
   sync: SyncDefinition,
   options: SyncRunRequestOptions = {}
 ): Promise<SyncRunRequestResult> {
+  resolveExecutionScopeAuthorization(runtime.projectId, {
+    execution,
+    authorization: runtime.runtimeAuthorization,
+  })
   assertAuthorized(runtime, { kind: "sync.run", syncId: sync.id })
   if (!runtime.storage.syncRuns) {
     throw new SyncValidationError("[Sixb] Sync run storage is not configured.")

package/src/testing/agent-execution.ts

@@ -1,4 +1,5 @@
 import { agentServiceAccountId } from "../agents/authority"
+import { SYSTEM_PRINCIPAL } from "../auth"
 import type { AuthStorage } from "../storage/auth"
 import { AuthStorageError } from "../storage/auth"
 import type { ExecutionStorage } from "../storage/executions"
@@ -8,35 +9,43 @@ export async function createTestAgentExecution(
   storage: { readonly auth?: AuthStorage; readonly executions: ExecutionStorage },
   input: {
     readonly projectId: string
-    readonly agentId: string
+    readonly actorId?: string
     readonly runId: string
     readonly executionId?: string
     readonly sourceExecutionId?: string
+    /** Conversational runs inherit authority; workflow fixtures use managed authority. */
+    readonly authority?: "managed" | "inherited"
   }
 ): Promise<string> {
-  const auth = storage.auth
-  if (!auth) throw new Error("Agent execution fixtures require auth storage.")
-  const serviceAccountId = agentServiceAccountId(input.agentId)
-  const serviceAccount = await auth.serviceAccounts.getById({
-    projectId: input.projectId,
-    id: serviceAccountId,
-  })
-  if (!serviceAccount) {
-    const now = new Date()
-    try {
-      await auth.serviceAccounts.create({
-        id: serviceAccountId,
-        projectId: input.projectId,
-        name: `Test Agent ${input.agentId}`,
-        description: `Test service account for Agent '${input.agentId}'.`,
-        status: "active",
-        createdByPrincipal: { type: "system", id: "test" },
-        createdAt: now,
-        updatedAt: now,
-      })
-    } catch (error) {
-      if (!(error instanceof AuthStorageError) || error.code !== "duplicate_service_account") {
-        throw error
+  const authority = input.authority ?? (input.actorId === undefined ? "inherited" : "managed")
+  if (authority === "managed" && input.actorId === undefined) {
+    throw new Error("Managed Agent execution fixtures require an agent id.")
+  }
+  const serviceAccountId = input.actorId ? agentServiceAccountId(input.actorId) : undefined
+  if (authority === "managed") {
+    const auth = storage.auth
+    if (!auth) throw new Error("Managed Agent execution fixtures require auth storage.")
+    const serviceAccount = await auth.serviceAccounts.getById({
+      projectId: input.projectId,
+      id: serviceAccountId!,
+    })
+    if (!serviceAccount) {
+      const now = new Date()
+      try {
+        await auth.serviceAccounts.create({
+          id: serviceAccountId!,
+          projectId: input.projectId,
+          name: `Test Agent ${input.actorId}`,
+          description: `Test service account for Agent '${input.actorId}'.`,
+          status: "active",
+          createdByPrincipal: SYSTEM_PRINCIPAL,
+          createdAt: now,
+          updatedAt: now,
+        })
+      } catch (error) {
+        if (!(error instanceof AuthStorageError) || error.code !== "duplicate_service_account") {
+          throw error
+        }
       }
     }
   }
@@ -72,10 +81,13 @@ export async function createTestAgentExecution(
       ? {}
       : { requestedBy: structuredClone(parent.requestedBy) }),
     correlationId: parent.correlationId,
-    authorizationRef: {
-      type: "principal",
-      principal: { type: "serviceAccount", id: serviceAccountId },
-    },
+    authorizationRef:
+      authority === "inherited"
+        ? structuredClone(parent.authorizationRef)
+        : {
+            type: "principal",
+            principal: { type: "serviceAccount", id: serviceAccountId! },
+          },
   })
   return executionId
 }