@sixb/core 0.1.20 → 0.1.22

package/src/execution/lineage.ts

@@ -0,0 +1,14 @@
+/**
+ * The nearest of an execution and its ancestors that `isOwner` accepts, walking up through
+ * `parentOf`: where a roll-up counts what the execution spent. Undefined when the walk runs out of
+ * known parents first.
+ */
+export function nearestOwner(
+  executionId: string,
+  parentOf: (executionId: string) => string | undefined,
+  isOwner: (executionId: string) => boolean
+): string | undefined {
+  let current: string | undefined = executionId
+  while (current !== undefined && !isOwner(current)) current = parentOf(current)
+  return current
+}

package/src/execution/object-reader-clearance.ts

@@ -0,0 +1,91 @@
+import { type PropertyClearance, resolvePropertyClearance } from "../objects/property-clearance"
+import type { OntologyRegistry } from "../ontology"
+import type { AppliedMarkings } from "../security/applied-markings"
+import type { EventOriginRef } from "../security/applied-markings-contribution"
+import type { AppliedMarkingsSnapshot } from "../security/applied-markings-snapshot"
+
+/** What one read may not return; `undefined` when it reads everything. */
+export type Clearance = PropertyClearance | undefined
+
+/**
+ * What one authority cannot read: the markings the code declares, and those the dataset versions
+ * projections applied add, for an authority they can affect.
+ *
+ * A reader they cannot affect, trusted code included, gets the code's clearance as a plain value:
+ * awaiting it costs one microtask, not a refresh. Otherwise the clearance is resolved for each
+ * snapshot, which rarely changes, so the last one is kept.
+ */
+export class ObjectReaderClearance {
+  readonly #ontology: OntologyRegistry
+  /** What the authority cannot read under the code's markings; absent when it reads everything. */
+  readonly #static: Clearance
+  /** The authority's clearances; absent when it is unrestricted. */
+  readonly #clearances?: ReadonlySet<string>
+  /** Present only when applied dataset versions can deny this authority more than the code. */
+  readonly #applied?: AppliedMarkings
+  #lastSnapshot?: AppliedMarkingsSnapshot
+  #lastClearance: Clearance
+
+  constructor(input: {
+    readonly ontology: OntologyRegistry
+    readonly clearances: ReadonlySet<string> | undefined
+    readonly appliedMarkings?: AppliedMarkings
+  }) {
+    this.#ontology = input.ontology
+    this.#clearances = input.clearances
+    this.#static = input.clearances && resolvePropertyClearance(input.ontology, input.clearances)
+
+    if (input.clearances && input.appliedMarkings?.affects(input.clearances)) {
+      this.#applied = input.appliedMarkings
+    }
+
+    Object.freeze(this)
+  }
+
+  /** What the authority cannot read now. */
+  current(): Clearance | Promise<Clearance> {
+    const applied = this.#applied
+    const clearances = this.#clearances
+    if (!applied || !clearances) return this.#static
+
+    return applied.current().then((snapshot) => {
+      if (snapshot !== this.#lastSnapshot) {
+        this.#lastClearance = resolvePropertyClearance(this.#ontology, clearances, snapshot)
+        this.#lastSnapshot = snapshot
+      }
+      return this.#lastClearance
+    })
+  }
+
+  /**
+   * What the authority cannot read in an object event. Reads the event's origin version only for
+   * an authority its markings affect.
+   */
+  forEvent(sources: EventSources): Clearance | Promise<Clearance> {
+    const applied = this.#applied
+    const clearances = this.#clearances
+    if (!applied || !clearances) return this.#static
+
+    return applied
+      .current()
+      .then((snapshot) =>
+        sources.origin ? applied.forEventOrigin(snapshot, sources.origin) : snapshot
+      )
+      .then((snapshot) =>
+        sources.earlier ? applied.forEarlierValues(snapshot, sources.objectTypeId) : snapshot
+      )
+      .then((snapshot) => resolvePropertyClearance(this.#ontology, clearances, snapshot))
+  }
+}
+
+/** Where the values of an object event came from. */
+export interface EventSources {
+  readonly objectTypeId: string
+  /** The projection that emitted the event, and the version it applied. */
+  readonly origin?: EventOriginRef
+  /**
+   * Whether the event holds values from before it, which came from versions applied earlier: an
+   * update or a deletion, or a record an action or a direct write took of projected values.
+   */
+  readonly earlier: boolean
+}

package/src/execution/object-reader-ontology.ts

@@ -0,0 +1,60 @@
+import {
+  type AuthorizedOntologySelection,
+  type AuthorizedOntologyView,
+  createAuthorizedOntologyView,
+} from "../objects/authorized-ontology-view"
+import type { OntologyRegistry } from "../ontology"
+import { assertObjectReadOutputWithinLimit } from "../storage"
+import type { ObjectReaderSecurity } from "./object-reader-security"
+
+/** The ontology a reader resolves against, and the part of it its authority may describe. */
+export class ObjectReaderOntology {
+  readonly registry: OntologyRegistry
+  readonly #security: ObjectReaderSecurity
+  #view?: AuthorizedOntologyView
+
+  constructor(registry: OntologyRegistry, security: ObjectReaderSecurity) {
+    this.registry = registry
+    this.#security = security
+    Object.freeze(this)
+  }
+
+  /** Inert metadata for the types the authority may view, built on first use. */
+  view(): AuthorizedOntologyView {
+    const authority = this.#security.authority
+    this.#view ??= createAuthorizedOntologyView({
+      ontology: this.registry,
+      selection: selectionForAuthority(this.#security, this.registry),
+      ...(authority.type === "delegated"
+        ? {
+            assertOutputWithinLimit: (value: unknown) =>
+              assertObjectReadOutputWithinLimit(value, authority.objectRead.limits),
+          }
+        : {}),
+    })
+    return this.#view
+  }
+}
+
+function selectionForAuthority(
+  security: ObjectReaderSecurity,
+  ontology: OntologyRegistry
+): AuthorizedOntologySelection {
+  const authority = security.authority
+
+  switch (authority.type) {
+    case "unrestricted":
+      return { kind: "all" }
+    case "principal":
+      return {
+        kind: "types",
+        objectTypeIds: ontology
+          .listObjectTypes()
+          // A type viewed through a condition is listed: the reader reads the objects it matches.
+          .filter((objectType) => security.isObjectTypeGranted(objectType.id, undefined))
+          .map((objectType) => objectType.id),
+      }
+    case "delegated":
+      return { kind: "selected", scope: authority.objectRead.scope }
+  }
+}

package/src/execution/object-reader-security.ts

@@ -0,0 +1,270 @@
+import { assertAuthorized, assertRuntimeAuthorizationBound, isAllowed } from "../authorization"
+import { AuthorizationError } from "../authorization/errors"
+import type { AuthorizationContext } from "../authorization/types"
+import { type Unreadable, unreadableError } from "../objects/property-clearance"
+import { bindCurrentUserPredicate } from "../objects/query/current-user"
+import type { ObjectQueryPredicate } from "../objects/query/ir"
+import {
+  createSelectedObjectQueryAdmission,
+  type SelectedObjectQueryAdmission,
+} from "../objects/query/selected-read-admission"
+import type { OntologyRegistry } from "../ontology"
+import type { UserRef } from "../ontology/user-ref"
+import type { AppliedMarkings } from "../security/applied-markings"
+import type {
+  CompiledConditionalObjectReadScope,
+  CompiledObjectReadStep,
+  ObjectLinkRow,
+} from "../storage"
+import { compileConditionalObjectReadScope } from "../storage/objects/read-scope"
+import type { resolveExecutionScopeAuthorization } from "./authorization"
+import { type Clearance, ObjectReaderClearance } from "./object-reader-clearance"
+import type { AuthorizablePrincipal, RuntimeAuthorization } from "./types"
+
+export type ResolvedExecutionAuthority = ReturnType<typeof resolveExecutionScopeAuthorization>
+
+export type RuntimeReadAuthorization = {
+  readonly projectId: string
+  readonly runtimeAuthorization: RuntimeAuthorization
+  readonly authorization?: AuthorizationContext
+}
+
+/** What a delegated authority selected: the object types, links, and queries it may read. */
+export interface ObjectReaderDelegation {
+  readonly objectTypeIds: ReadonlySet<string>
+  readonly linkDefinitions: ReadonlySet<string>
+  readonly queryAdmission: SelectedObjectQueryAdmission
+}
+
+/**
+ * Who reads, and what it may read: the exact execution authority, the selection a delegated one
+ * carries, the conditions a principal reads some types through, and its clearance. It decides
+ * whether an object type or a link is viewable.
+ *
+ * A type a principal views only through a condition is viewable here, and nowhere else: the
+ * reader's storage shows only the objects the condition matches. A check that answers for one
+ * object of such a type reads that object through the same storage.
+ */
+export class ObjectReaderSecurity {
+  /** The registered authority the reader is bound to. */
+  readonly authorization: RuntimeAuthorization
+  readonly authority: ResolvedExecutionAuthority
+  /** The authority as generic authorization checks take it. */
+  readonly runtime: RuntimeReadAuthorization
+  /** Present for delegated authority only. */
+  readonly delegation?: ObjectReaderDelegation
+  readonly clearance: ObjectReaderClearance
+  /** The user `currentUser()` stands for in this reader's queries; absent when no user reads. */
+  readonly requestingUser?: UserRef
+  /** What the reader's storage reads through: present when a principal views a type under one. */
+  readonly conditionalScope?: CompiledConditionalObjectReadScope
+  /** The properties each conditioned type's condition reads, which its clearance must show. */
+  readonly #conditionProperties: ReadonlyMap<string, readonly string[]>
+
+  constructor(input: {
+    readonly authorization: RuntimeAuthorization
+    readonly authority: ResolvedExecutionAuthority
+    readonly projectId: string
+    readonly ontology: OntologyRegistry
+    readonly appliedMarkings?: AppliedMarkings
+    readonly requestedBy: AuthorizablePrincipal | undefined
+  }) {
+    const authority = input.authority
+    this.authorization = input.authorization
+    this.authority = authority
+    if (input.requestedBy?.type === "user") {
+      this.requestingUser = Object.freeze({ type: "user", id: input.requestedBy.id })
+    }
+    this.runtime = Object.freeze({
+      projectId: input.projectId,
+      runtimeAuthorization: input.authorization,
+      ...(authority.type === "principal" ? { authorization: authority.context } : {}),
+    })
+
+    if (authority.type === "delegated") {
+      const scope = authority.objectRead.scope
+      this.delegation = Object.freeze({
+        objectTypeIds: new Set(scope.objects.map((object) => object.objectTypeId)),
+        linkDefinitions: new Set(scope.steps.map(delegatedLinkDefinitionKey)),
+        queryAdmission: createSelectedObjectQueryAdmission(scope),
+      })
+    }
+
+    const conditions = authority.type === "principal" ? authority.context.viewConditions : undefined
+    this.#conditionProperties = new Map(
+      [...(conditions ?? [])].map(([objectTypeId, predicates]) => [
+        objectTypeId,
+        [...new Set(predicates.flatMap(propertiesReadBy))],
+      ])
+    )
+
+    if (authority.type === "principal" && conditions && conditions.size > 0) {
+      // A reader sees an object any of its conditions matches. In a condition, `currentUser()` is
+      // the principal the grant was resolved for, when it is a user: never the user who requested
+      // the execution, which an agent's service account runs for. Otherwise it is no one.
+      const principal = authority.context.principal
+      const grantee: UserRef | undefined =
+        principal.type === "user" ? { type: "user", id: principal.id } : undefined
+
+      this.conditionalScope = compileConditionalObjectReadScope({
+        kind: "conditional",
+        conditions: [...conditions].map(([objectTypeId, predicates]) => ({
+          objectTypeId,
+          predicate: bindCurrentUserPredicate(anyOf(predicates), grantee),
+        })),
+      })
+    }
+
+    this.clearance = new ObjectReaderClearance({
+      ontology: input.ontology,
+      clearances: clearancesForAuthority(authority),
+      ...(input.appliedMarkings === undefined ? {} : { appliedMarkings: input.appliedMarkings }),
+    })
+
+    Object.freeze(this)
+  }
+
+  assertObjectTypesViewable(objectTypeIds: readonly string[], clearance: Clearance): void {
+    if (this.delegation) {
+      for (const objectTypeId of new Set(objectTypeIds)) {
+        if (this.delegation.objectTypeIds.has(objectTypeId)) continue
+        throw new AuthorizationError(
+          `delegated:object.view:${objectTypeId}`,
+          `[Sixb] Delegated authorization does not select object type '${objectTypeId}'.`
+        )
+      }
+    } else {
+      this.assertObjectTypesGranted(objectTypeIds, clearance)
+    }
+
+    if (!clearance) return
+
+    for (const objectTypeId of new Set(objectTypeIds)) {
+      const unreadable = clearance.unreadableType(objectTypeId)
+      if (unreadable) throw unreadableError(unreadable)
+    }
+  }
+
+  /**
+   * Refuse a type a principal holds no view grant for, before its clearance is applied to what it
+   * reads. A type viewed through a condition passes while the clearance shows every property the
+   * condition reads.
+   */
+  assertObjectTypesGranted(objectTypeIds: readonly string[], clearance: Clearance): void {
+    for (const objectTypeId of new Set(objectTypeIds)) {
+      if (!this.#conditionProperties.has(objectTypeId)) {
+        assertAuthorized(this.runtime, { kind: "object.view", objectTypeId })
+        continue
+      }
+
+      assertRuntimeAuthorizationBound(this.runtime)
+
+      const unreadable = this.#unreadableCondition(objectTypeId, clearance)
+      if (unreadable) throw unreadableError(unreadable)
+    }
+  }
+
+  /** Whether the principal views this type only through a condition, which decides per object. */
+  viewsThroughCondition(objectTypeId: string): boolean {
+    return this.#conditionProperties.has(objectTypeId)
+  }
+
+  isObjectTypeGranted(objectTypeId: string, clearance: Clearance): boolean {
+    if (this.delegation) return this.delegation.objectTypeIds.has(objectTypeId)
+
+    if (this.#conditionProperties.has(objectTypeId)) {
+      return this.#unreadableCondition(objectTypeId, clearance) === undefined
+    }
+
+    return isAllowed(this.runtime.authorization, { kind: "object.view", objectTypeId })
+  }
+
+  isObjectTypeViewable(objectTypeId: string, clearance: Clearance): boolean {
+    if (clearance?.unreadableType(objectTypeId)) return false
+    return this.isObjectTypeGranted(objectTypeId, clearance)
+  }
+
+  isLinkViewable(link: ObjectLinkRow, clearance: Clearance): boolean {
+    if (
+      !this.isObjectTypeViewable(link.sourceTypeId, clearance) ||
+      !this.isObjectTypeViewable(link.targetTypeId, clearance) ||
+      clearance?.unreadableLink(link.sourceTypeId, link.linkId)
+    ) {
+      return false
+    }
+
+    return this.delegation?.linkDefinitions.has(delegatedLinkDefinitionKey(link)) ?? true
+  }
+
+  #unreadableCondition(objectTypeId: string, clearance: Clearance): Unreadable | undefined {
+    const propertyIds = this.#conditionProperties.get(objectTypeId)
+    return propertyIds && unreadableConditionOf(objectTypeId, propertyIds, clearance)
+  }
+}
+
+/**
+ * Which objects match a condition would reveal a property the reader cannot read, so a clearance
+ * that hides one, a marking applied by a dataset version included, hides the whole type.
+ */
+function unreadableConditionOf(
+  objectTypeId: string,
+  propertyIds: readonly string[],
+  clearance: Clearance
+): Unreadable | undefined {
+  for (const propertyId of propertyIds) {
+    const marking = clearance?.missingMarking(objectTypeId, propertyId)
+    if (marking === undefined) continue
+
+    return {
+      marking,
+      message: `[Sixb] Cannot read '${objectTypeId}': the condition it is viewed through reads '${objectTypeId}.${propertyId}', which requires clearance for marking '${marking}'.`,
+    }
+  }
+
+  return undefined
+}
+
+function propertiesReadBy(predicate: ObjectQueryPredicate): readonly string[] {
+  switch (predicate.op) {
+    case "and":
+    case "or":
+      return predicate.items.flatMap(propertiesReadBy)
+    case "not":
+      return propertiesReadBy(predicate.item)
+    case "constant":
+      return []
+    default:
+      return [predicate.propertyId]
+  }
+}
+
+function anyOf(predicates: readonly ObjectQueryPredicate[]): ObjectQueryPredicate {
+  return predicates.length === 1 ? predicates[0]! : { op: "or", items: predicates }
+}
+
+/**
+ * Unrestricted authority reads every property. A principal reads what its roles clear; delegated
+ * shared access carries no clearance, so no share can expose a marked property.
+ */
+function clearancesForAuthority(
+  authority: ResolvedExecutionAuthority
+): ReadonlySet<string> | undefined {
+  switch (authority.type) {
+    case "unrestricted":
+      return undefined
+    case "principal":
+      return authority.context.clearances ?? new Set()
+    case "delegated":
+      return new Set()
+  }
+}
+
+function delegatedLinkDefinitionKey(
+  input:
+    | Pick<CompiledObjectReadStep, "sourceObjectTypeId" | "linkId" | "targetObjectTypeId">
+    | Pick<ObjectLinkRow, "sourceTypeId" | "linkId" | "targetTypeId">
+): string {
+  return "sourceObjectTypeId" in input
+    ? JSON.stringify([input.sourceObjectTypeId, input.linkId, input.targetObjectTypeId])
+    : JSON.stringify([input.sourceTypeId, input.linkId, input.targetTypeId])
+}

package/src/execution/object-reader-users.ts

@@ -0,0 +1,122 @@
+import type { UserExpansionPlan } from "../objects/query/user-expansions"
+import type { OntologyRegistry } from "../ontology"
+import { isUserRef, isUserRefPropertySchema } from "../ontology/user-ref"
+import type {
+  AuthUserStore,
+  ExpandedLinkValue,
+  ObjectRow,
+  ObjectRowUsers,
+  UserRecord,
+} from "../storage"
+import { toUserProfile } from "../users/execution"
+
+/** Ids read per storage call: one call for a typical page, bounded for the largest. */
+const LOOKUP_BATCH_SIZE = 500
+
+/** One expanded property of one row, and the member ids its value holds, in stored order. */
+interface UserSlot {
+  readonly users: ObjectRowUsers
+  readonly propertyId: string
+  readonly many: boolean
+  readonly ids: readonly string[]
+}
+
+/**
+ * Attach the member profiles a query expands to the rows the reader returns.
+ *
+ * Every row whose type declares an expanded property gets `users`, so reading an entry never
+ * throws. An entry is left out when the reader may not view the directory, and when the reader
+ * cannot read the value: the rows have already lost their hidden values and carry `redactions`,
+ * so a marked value is never looked up. The rows must be the reader's own copies.
+ */
+export async function attachUserProfiles(input: {
+  readonly rows: readonly ObjectRow[]
+  readonly plan: UserExpansionPlan
+  readonly ontology: OntologyRegistry
+  readonly projectId: string
+  readonly canViewUsers: boolean
+  readonly users: AuthUserStore | undefined
+}): Promise<void> {
+  const slots: UserSlot[] = []
+  collectSlots(input.rows, input.plan, input.ontology, slots)
+
+  if (!input.canViewUsers) return
+
+  const records = await readUsers(input, slots)
+
+  for (const slot of slots) {
+    slot.users[slot.propertyId] = expandedValue(slot, records)
+  }
+}
+
+// An array keeps its members in order and skips ids no member has; a single reference to no
+// member, or an empty one, is `null`.
+function expandedValue(slot: UserSlot, records: ReadonlyMap<string, UserRecord>) {
+  const profiles = slot.ids.flatMap((id) => {
+    const record = records.get(id)
+    return record ? [toUserProfile(record)] : []
+  })
+
+  return slot.many ? profiles : (profiles[0] ?? null)
+}
+
+function collectSlots(
+  rows: readonly ObjectRow[],
+  plan: UserExpansionPlan,
+  ontology: OntologyRegistry,
+  into: UserSlot[]
+): void {
+  for (const row of rows) {
+    const properties = ontology.getObjectTypeById(row.objectTypeId)?.properties ?? []
+
+    for (const propertyId of plan.users) {
+      const property = properties.find((candidate) => candidate.id === propertyId)
+      if (!property || !isUserRefPropertySchema(property.schema)) continue
+
+      row.users ??= {}
+      if (row.redactions?.[propertyId]) continue
+
+      into.push({
+        users: row.users,
+        propertyId,
+        many: property.schema !== "userRef",
+        ids: userIdsOf(row.properties[propertyId]),
+      })
+    }
+
+    for (const link of plan.links) {
+      collectSlots(linkedRows(row.links?.[link.linkId]), link.plan, ontology, into)
+    }
+  }
+}
+
+async function readUsers(
+  input: { readonly projectId: string; readonly users: AuthUserStore | undefined },
+  slots: readonly UserSlot[]
+): Promise<ReadonlyMap<string, UserRecord>> {
+  const records = new Map<string, UserRecord>()
+  const ids = [...new Set(slots.flatMap((slot) => slot.ids))]
+  if (!input.users || ids.length === 0) return records
+
+  for (let start = 0; start < ids.length; start += LOOKUP_BATCH_SIZE) {
+    const batch = ids.slice(start, start + LOOKUP_BATCH_SIZE)
+    for (const record of await input.users.getByIds({ projectId: input.projectId, ids: batch })) {
+      records.set(record.id, record)
+    }
+  }
+
+  return records
+}
+
+// A single reference, or the references of an array in order. Anything else holds no member.
+function userIdsOf(value: unknown): string[] {
+  if (isUserRef(value)) return [value.id]
+  if (!Array.isArray(value)) return []
+  return value.filter(isUserRef).map((ref) => ref.id)
+}
+
+function linkedRows(value: ExpandedLinkValue | undefined): readonly ObjectRow[] {
+  if (value === undefined || value === null) return []
+  if (Array.isArray(value)) return value
+  return [value as ObjectRow]
+}

package/src/execution/preparation.ts

@@ -0,0 +1,78 @@
+import { type PreparedActionRequest, prepareActionRequest } from "../actions/request"
+import type { SixbRuntimeContext } from "../runtime/types"
+import { WorkflowValidationError } from "../workflows/errors"
+import { type PreparedWorkflowRequest, prepareWorkflowRequest } from "../workflows/request"
+import type { WorkflowDefinition } from "../workflows/types"
+import type { ExecutionContext } from "./types"
+
+export interface ActionRequestToPrepare {
+  readonly actionId: string
+  readonly subject?: PreparedActionRequest["subject"]
+  readonly params?: Record<string, unknown>
+}
+
+export interface WorkflowRequestToPrepare {
+  readonly workflowId: string
+  readonly input?: Readonly<Record<string, unknown>>
+}
+
+/** Admit a request with a bound SDK's authority, as it would run, without running it. */
+interface RequestPreparation {
+  action(input: ActionRequestToPrepare): Promise<PreparedActionRequest>
+  workflow(input: WorkflowRequestToPrepare): PreparedWorkflowRequest
+}
+
+const preparationKey = Symbol("sixb.requestPreparation")
+
+interface PreparationOwner {
+  readonly [preparationKey]?: RequestPreparation
+}
+
+/** Let infrastructure prepare requests with a bound SDK's authority. */
+export function registerRequestPreparation(
+  owner: object,
+  runtime: SixbRuntimeContext,
+  execution: ExecutionContext,
+  workflows: { getById(workflowId: string): WorkflowDefinition | null }
+): void {
+  const preparation: RequestPreparation = {
+    action: (input) => prepareActionRequest(runtime, execution, input),
+    workflow: (input) => {
+      const workflow = workflows.getById(input.workflowId)
+      if (!workflow) {
+        throw new WorkflowValidationError(`[Sixb] Unknown workflow '${input.workflowId}'`)
+      }
+      return prepareWorkflowRequest(runtime, execution, workflow, input.input)
+    },
+  }
+  Object.defineProperty(owner, preparationKey, {
+    configurable: false,
+    enumerable: false,
+    value: preparation,
+    writable: false,
+  })
+}
+
+/** Admit an Action request as `sixb.actions.request` would, and return it normalized. */
+export function prepareBoundActionRequest(
+  sixb: object,
+  input: ActionRequestToPrepare
+): Promise<PreparedActionRequest> {
+  return requirePreparation(sixb).action(input)
+}
+
+/** Admit a workflow start as `sixb.workflows.requestById` would, and return its input snapshot. */
+export function prepareBoundWorkflowRequest(
+  sixb: object,
+  input: WorkflowRequestToPrepare
+): PreparedWorkflowRequest {
+  return requirePreparation(sixb).workflow(input)
+}
+
+function requirePreparation(sixb: object): RequestPreparation {
+  const preparation = (sixb as PreparationOwner)[preparationKey]
+  if (!preparation) {
+    throw new Error("[Sixb] Request preparation is not registered for this execution.")
+  }
+  return preparation
+}

package/src/execution/request.ts

@@ -26,6 +26,7 @@ export type {
   ExecutionAgentRequestInput,
   ExecutionAgentRunResult,
   ListExecutionAgentThreadsInput,
+  ObservedAgentThreadsRuntime,
 } from "../agents/execution"
 export type { AgentDescriptor } from "../agents/types"
 export type { AuthorizationContext } from "../authorization"
@@ -62,6 +63,7 @@ export type {
   WorkflowRunView,
   WorkflowsRuntime,
 } from "../workflows/execution"
+export { prepareBoundActionRequest, prepareBoundWorkflowRequest } from "./preparation"
 export type { AuthorizationRef, ExecutionContext } from "./types"
 
 export type RequestExecutionAuthorization =