@sixb/core 0.1.17 → 0.1.19

package/src/index.ts

@@ -64,6 +64,7 @@ export {
   userRef,
   valueTypeRef,
 } from "./ontology"
+export type { OntologyDoc, OntologyDocsCatalog, OntologyDocsInput } from "./ontology/docs"
 
 // ── Actions ─────────────────────────────────────────────────
 
@@ -115,12 +116,8 @@ export type {
   ObjectActionDefinition,
   ObjectActionParamsBuilder,
   ObjectActionPhaseBuilder,
-  RequestActionAndWaitInput,
-  RequestActionAndWaitOptions,
   RequestActionInput,
   RequestActionOptions,
-  RequestActionResult,
-  WaitForActionRunInput,
 } from "./actions"
 export {
   ActionDefinitionError,
@@ -136,11 +133,7 @@ export {
  * it to write `catch (error) { if (error instanceof EditBatchError) … }`.
  */
 export { EditBatchError } from "./edits"
-export {
-  ActionRunFailedError,
-  ActionRunTimeoutError,
-  ActionValidationError,
-} from "./objects/action"
+export { ActionRunFailedError, ActionValidationError } from "./objects/action"
 
 // ── Datasets ────────────────────────────────────────────────
 
@@ -220,6 +213,7 @@ export {
 
 export type {
   InferObjectProperties,
+  InferObjectReadProperties,
   InferPropertySemanticType,
   InferPropertyUnit,
   InferPropertyValue,
@@ -231,17 +225,7 @@ export type {
 // ── Events ──────────────────────────────────────────────────
 
 export type {
-  ActionCompletedEvent,
-  ActionEvent,
   ActionEventOrigin,
-  ActionEventSelectorBuilder,
-  ActionEventSelectorContext,
-  ActionEventSelectorEvent,
-  ActionEventSelectorOperation,
-  ActionEventToken,
-  ActionEventTokenOf,
-  ActionFailedEvent,
-  ActionRequestedEvent,
   DatasetEvent,
   DatasetEventSelectorBuilder,
   DatasetEventSelectorContext,
@@ -464,6 +448,7 @@ export type {
   BreadthSelector,
   BreadthTarget,
   DefineGroupOptions,
+  DefineMarkingOptions,
   DefineMembershipPolicyOptions,
   DefineRoleOptions,
   EditGrant,
@@ -473,10 +458,13 @@ export type {
   GroupReference,
   ManageGrant,
   ManageGrantTarget,
+  MarkingDefinition,
   MembershipOperation,
   MembershipPolicyDefinition,
   ObserveGrant,
   ObserveGrantTarget,
+  RedactionReason,
+  Redactions,
   RegisteredSecurityDefinitions,
   RoleDefinition,
   RunGrant,
@@ -491,6 +479,7 @@ export {
   applications,
   can,
   defineGroup,
+  defineMarking,
   defineMembershipPolicy,
   defineRole,
   every,
@@ -563,6 +552,7 @@ export type {
   BlobInfo,
   BlobStorage,
   FileRef,
+  OpenedFileRef,
 } from "./blob-storage"
 export {
   DEFAULT_SIMPLE_FILE_UPLOAD_BYTES,
@@ -579,6 +569,7 @@ export {
 export type {
   DatasetProducer,
   DatasetRow,
+  DatasetVersion,
   LakeStorage,
   LakeStorageWithSql,
 } from "./lake-storage"
@@ -892,7 +883,13 @@ export type {
 export type { CreateFileDownloadUrlOptions, FileDownloadUrl } from "./blob-storage/download-urls"
 export type { BlobsRuntime } from "./blob-storage/execution"
 export type { ConnectorRuntime } from "./connectors/execution"
-export type { DatasetIngestInput, DatasetIngestResult, DatasetsRuntime } from "./datasets/execution"
+export type {
+  DatasetIngestInput,
+  DatasetIngestResult,
+  DatasetReadRowsInput,
+  DatasetRows,
+  DatasetsRuntime,
+} from "./datasets/execution"
 export type {
   SixbActionPhaseFailedContext,
   SixbErrorContext,
@@ -943,12 +940,15 @@ export type {
   BatchItemResult,
   CreateSixbOptions,
   DefinitionCatalog,
+  FileListPropertyToken,
+  FilePropertyToken,
   ListResult,
   ListResultWithoutTotal,
   ObjectByIdHandle,
   ObjectExpandBuilder,
   ObjectExpandOptions,
   ObjectExpansionSort,
+  ObjectFileHandle,
   ObjectQueryBuilder,
   ObjectQueryFacetBucket,
   ObjectQueryFacetInput,
@@ -1025,6 +1025,9 @@ export type {
   AgentContextInput,
   AgentContextOrigin,
   AgentContextPart,
+  AgentContinuationPart,
+  AgentDefinitions,
+  AgentDefinitionsInput,
   AgentDescriptor,
   AgentFileDataProjection,
   AgentFileDataResolverInput,
@@ -1033,17 +1036,20 @@ export type {
   AgentMessagePart,
   AgentMessagePartType,
   AgentMessageRole,
+  AgentProjectFile,
   AgentProviderStatePart,
   AgentReasoning,
-  AgentReasoningLevel,
   AgentReasoningPart,
   AgentReference,
   AgentRequestErrorCode,
+  AgentSkillCatalog,
+  AgentSkillDefinition,
   AgentStepStartPart,
   AgentTextPart,
   AgentToolArtifact,
   AgentToolArtifactPutInput,
   AgentToolArtifacts,
+  AgentToolAttachments,
   AgentToolCallPart,
   AgentToolCallState,
   AgentToolCatalog,
@@ -1060,6 +1066,7 @@ export type {
   AgentToolRunBuilder,
   AgentToolRunContext,
   AgentToolRunInfo,
+  AgentToolRuntimeFacade,
   AgentToolTextContent,
   AgentUsageReference,
   InferAgentToolInput,

package/src/materialization/model.ts

@@ -3,6 +3,7 @@ import type { EventOrigin } from "../events/envelope"
 import type { PropertyChange, PropertyChangeMap } from "../events/property-changes"
 import type { JsonValue } from "../json"
 import type { ProjectionProtocolIdentity, ProjectionRunFailureCode } from "../projections/types"
+import type { RecordActionRunInput } from "../storage/action-runs/types"
 import type { ObjectVectorWrite } from "./vectors"
 
 export type { ProjectionProtocolIdentity } from "../projections/types"
@@ -120,16 +121,32 @@ interface BaseOntologyEditCommit {
   readonly operations: readonly OntologyEditOperation[]
 }
 
+interface AtomicOntologyEditCommit extends BaseOntologyEditCommit {
+  readonly mode: "atomic"
+  readonly vectorWrites?: readonly ObjectVectorWrite[]
+  readonly expectedObjects: readonly ExpectedObjectRevision[]
+  readonly expectedLinks: readonly ExpectedLinkRevision[]
+  readonly expectedLinkScopes: readonly ExpectedLinkScopeRevision[]
+}
+
 export type OntologyEditCommit =
-  | (BaseOntologyEditCommit & {
-      readonly mode: "atomic"
-      readonly source:
-        | { readonly kind: "action"; readonly actionId: string; readonly runId: string }
-        | { readonly kind: "runtime"; readonly requestId: string }
-      readonly vectorWrites?: readonly ObjectVectorWrite[]
-      readonly expectedObjects: readonly ExpectedObjectRevision[]
-      readonly expectedLinks: readonly ExpectedLinkRevision[]
-      readonly expectedLinkScopes: readonly ExpectedLinkScopeRevision[]
+  | (AtomicOntologyEditCommit & {
+      readonly source: {
+        readonly kind: "action"
+        readonly actionId: string
+        readonly runId: string
+      }
+      /**
+       * The run's terminal record, inserted in the commit's transaction so that its edits never
+       * land without the run that made them.
+       *
+       * It is not part of the commit's intent: replaying the commit returns the stored commit and
+       * inserts nothing, whatever record the replay carries.
+       */
+      readonly run: RecordActionRunInput
+    })
+  | (AtomicOntologyEditCommit & {
+      readonly source: { readonly kind: "runtime"; readonly requestId: string }
     })
   | (BaseOntologyEditCommit & {
       readonly mode: "continue"

package/src/materializer/README.md

@@ -158,7 +158,12 @@ its mutable overrides let operation N+1 observe operation N. In `continue` mode,
 operation rolls back only its working override; provider and infrastructure failures abort the
 whole transaction.
 
-Action-backed edits validate the trusted Action execution, the run's immutable `executionId`, and the running-state fence inside the commit transaction before new work. Exact replay remains valid after the run becomes terminal. Their semantic result lives only in the ontology commit, correlated by Action origin; the Action run is not a second commit ledger.
+Action-backed edits carry the run's terminal record. The commit validates the trusted Action
+execution and the record's `executionId`, then inserts the record in its own transaction before new
+work, so edits never land without the run that made them and a run id commits once: a second insert
+for it fails the commit. An exact replay returns the stored commit and inserts nothing; the carried
+record is not part of the commit's intent. The edits' semantic result lives only in the ontology
+commit, correlated by Action origin; the Action run is not a second commit ledger.
 
 ## Telemetry append
 

package/src/materializer/edits/commit.ts

@@ -9,7 +9,7 @@ import type {
   OntologyMaterializationOrigin,
   OntologyOperationOutcome,
 } from "../../materialization/model"
-import type { Storage } from "../../storage"
+import type { RecordActionRunInput, Storage } from "../../storage"
 import type { MaterializationSession, OntologyCommitWrite } from "../../storage/ontology"
 import type { MaterializerContext, MaterializerStorage } from "../context"
 import { replayCommit, withSerializationRetry } from "../execution/commit-lifecycle"
@@ -67,7 +67,7 @@ async function prepareEditCommit(
   const identity = createTimedCommitIdentity({
     projectId: context.projectId,
     idempotencyKey,
-    normalizedCallerIntent: input,
+    normalizedCallerIntent: editIntent(input),
     now: context.clock(),
   })
   return {
@@ -86,24 +86,15 @@ function editIdempotencyKey(input: NormalizedEditCommit): string {
   return createRuntimeIdempotencyKey(input.source.requestId)
 }
 
-async function lockActionRunForMaterialization(
-  storage: Storage,
-  projectId: string,
-  input: NormalizedEditCommit,
-  execution: MaterializerExecution
-): Promise<void> {
-  if (input.source.kind !== "action") return
-  if (!storage.actionRuns) {
-    throw new MaterializationValidationError(
-      "Storage does not provide Action run capabilities required by this commit."
-    )
-  }
-  const run = await storage.actionRuns.lockForMaterialization({
-    projectId,
-    actionId: input.source.actionId,
-    runId: input.source.runId,
-  })
-  assertMaterializerRunExecution(execution, run.executionId, `Action run '${run.id}'`)
+/**
+ * What a replay of the commit must repeat: its edits, without the run record an Action commit
+ * carries. That record is written by the commit that inserts it, and its timestamps differ on
+ * every attempt.
+ */
+function editIntent(input: NormalizedEditCommit): unknown {
+  if (!("run" in input)) return input
+  const { run: _run, ...intent } = input
+  return intent
 }
 
 async function validateMutationExecution(
@@ -122,24 +113,48 @@ async function validateMutationExecution(
     id: input.source.actionId,
     runId: input.source.runId,
   })
-  if (!storage.actionRuns) {
+  const run = requireActionRun(input)
+  if (run.projectId !== projectId || run.id !== input.source.runId) {
     throw new MaterializationValidationError(
-      "Storage does not provide Action run capabilities required by this commit."
+      `The record carried by Action run '${input.source.runId}' belongs to another run.`
     )
   }
-  const run = await storage.actionRuns.getById({ projectId, id: input.source.runId })
-  if (!run) {
-    throw new MaterializationValidationError(`Action run '${input.source.runId}' was not found.`)
-  }
   if (run.actionId !== input.source.actionId) {
     throw new MaterializationConflictError(
       "run-correlation",
       `Action run '${run.id}' does not belong to action '${input.source.actionId}'.`
     )
   }
+  if (run.status !== "succeeded" || run.phase !== "commit") {
+    throw new MaterializationValidationError(
+      `Action run '${run.id}' commits its edits only as a succeeded run in its commit phase.`
+    )
+  }
   assertMaterializerRunExecution(execution, run.executionId, `Action run '${run.id}'`)
 }
 
+/**
+ * Insert the run that made these edits, in the commit's transaction: the edits, their outbox facts,
+ * and the run record land together or not at all. A run already recorded fails the commit, since a
+ * run id is recorded once.
+ */
+async function recordActionRun(storage: Storage, input: NormalizedEditCommit): Promise<void> {
+  if (input.source.kind !== "action") return
+  if (!storage.actionRuns) {
+    throw new MaterializationValidationError(
+      "Storage does not provide Action run capabilities required by this commit."
+    )
+  }
+  await storage.actionRuns.record(requireActionRun(input))
+}
+
+function requireActionRun(input: NormalizedEditCommit): RecordActionRunInput {
+  if (!("run" in input)) {
+    throw new MaterializationValidationError("An Action commit must carry its run's record.")
+  }
+  return input.run
+}
+
 async function executeEditCommit(
   context: MaterializerContext,
   command: PreparedEditCommit
@@ -167,12 +182,7 @@ async function executeEditTransaction(
   )
   if (replay) return replay
 
-  await lockActionRunForMaterialization(
-    storage,
-    context.projectId,
-    command.input,
-    command.execution
-  )
+  await recordActionRun(storage, command.input)
 
   const session = await beginEditMaterialization(context, storage, command)
   const workingState = await loadEditWorkingState(

package/src/materializer/shared/normalize.ts

@@ -284,17 +284,6 @@ export function normalizeOntologyEditCommit(input: OntologyEditCommit): Ontology
     })
   }
 
-  const source =
-    input.source.kind === "action"
-      ? Object.freeze({
-          kind: "action" as const,
-          actionId: normalizeNonblank(input.source.actionId, "Action id"),
-          runId: normalizeNonblank(input.source.runId, "Action run id"),
-        })
-      : Object.freeze({
-          kind: "runtime" as const,
-          requestId: normalizeNonblank(input.source.requestId, "Runtime request id"),
-        })
   if (input.vectorWrites?.length && (operations.length || input.source.kind !== "runtime")) {
     throw new MaterializationValidationError(
       "Vector writes require a dedicated atomic runtime commit."
@@ -305,12 +294,11 @@ export function normalizeOntologyEditCommit(input: OntologyEditCommit): Ontology
   const expectedLinks = input.expectedLinks.map(normalizeExpectedLink)
   const expectedLinkScopes = input.expectedLinkScopes.map(normalizeExpectedLinkScope)
 
-  return Object.freeze({
-    mode: "atomic",
+  const atomic = {
+    mode: "atomic" as const,
     ...(input.vectorWrites === undefined
       ? {}
       : { vectorWrites: structuredClone(input.vectorWrites) }),
-    source,
     operations: Object.freeze(operations),
     expectedObjects: deduplicateExpectations(
       expectedObjects,
@@ -327,6 +315,29 @@ export function normalizeOntologyEditCommit(input: OntologyEditCommit): Ontology
       (value) => linkScopeKey(value.source, value.linkId),
       "Expected link scopes"
     ),
+  }
+
+  if (input.source.kind === "action") {
+    if (!("run" in input) || input.run === undefined) {
+      throw new MaterializationValidationError("An Action commit must carry its run's record.")
+    }
+    return Object.freeze({
+      ...atomic,
+      source: Object.freeze({
+        kind: "action" as const,
+        actionId: normalizeNonblank(input.source.actionId, "Action id"),
+        runId: normalizeNonblank(input.source.runId, "Action run id"),
+      }),
+      // Validated by the Action run storage when the commit inserts it.
+      run: structuredClone(input.run),
+    })
+  }
+  return Object.freeze({
+    ...atomic,
+    source: Object.freeze({
+      kind: "runtime" as const,
+      requestId: normalizeNonblank(input.source.requestId, "Runtime request id"),
+    }),
   })
 }
 

package/src/models/catalog.ts

@@ -13,7 +13,11 @@ import {
   type ModelDefinition,
 } from "./definitions"
 import { assertEmbeddingModel, type EmbeddingModel } from "./embedding-model"
-import type { LanguageModel } from "./language-model"
+import {
+  type LanguageModel,
+  MODEL_REASONING_LEVELS,
+  modelReasoningSupportIssue,
+} from "./language-model"
 import { assertRerankingModel, type RerankingModel } from "./reranking-model"
 
 /** Stable identity of a configured provider binding. */
@@ -143,7 +147,10 @@ function createLanguageCatalog(
     throw new RuntimeError("[Sixb] 'models.language' must be an array of Sixb language models.")
   }
 
-  const index = indexModelBindings(models, "language", assertLanguageModel)
+  const index = indexModelBindings(models, "language", (model, position) => {
+    assertLanguageModel(model, position)
+    assertDefaultReasoning(model, position)
+  })
   const [defaultEntry] = index.list()
   if (!defaultEntry) {
     throw new RuntimeError(
@@ -164,6 +171,23 @@ function createEmbeddingCatalog(
   return indexModelBindings(models ?? [], "embedding", assertEmbeddingModel)
 }
 
+// Capabilities known without catalog I/O. Unknown support is accepted: providers fall back to their
+// default when a resolved model turns out not to support the level.
+function assertDefaultReasoning(model: LanguageModel, index: number): void {
+  const reasoning: unknown = model.defaultReasoning
+  if (reasoning === undefined) return
+  if (!(MODEL_REASONING_LEVELS as readonly unknown[]).includes(reasoning)) {
+    throw invalidLanguageModel(
+      index,
+      `expected 'defaultReasoning' to be one of: ${MODEL_REASONING_LEVELS.join(", ")}`
+    )
+  }
+  const issue = modelReasoningSupportIssue(model.definition.capabilities.reasoning, reasoning)
+  if (issue !== undefined) {
+    throw invalidLanguageModel(index, `default reasoning '${reasoning}' cannot be used: ${issue}`)
+  }
+}
+
 function assertLanguageModel(model: unknown, index: number): asserts model is LanguageModel {
   if ((typeof model !== "object" && typeof model !== "function") || model === null) {
     throw invalidLanguageModel(index, "expected a Sixb LanguageModel instance")

package/src/models/execution/README.md

@@ -43,9 +43,10 @@ unknown input usage and unresolved capacity. Inference is never retried here.
 replays accounting only, never inference; see the
 [worker recovery contract](../../../../agent-worker/docs/usage-accounting.md).
 
-Direct provider calls bypass this session. Webhook handlers have no bound model execution attempt;
-they must dispatch an action for accounted calls. A process crash before accounting is captured
-can still leave provider billing outside the ledger.
+An Agent run binds its own recorder to its SDK, so calls from its tools share the run's admission,
+failure state and cancellation. Direct provider calls bypass this session. Webhook handlers have no
+bound model execution attempt; they must dispatch an action for accounted calls. A process crash
+before accounting is captured can still leave provider billing outside the ledger.
 
 ## Reranking flow
 

package/src/models/execution/binding.ts

@@ -1,10 +1,16 @@
 import type { ModelsRuntime } from "../generation-types"
+import type { AiModelCallRecorder } from "./model-call-recorder"
 
 export interface ModelExecutionAttempt {
   readonly attempt: number
   readonly signal: AbortSignal
   /** Internal durable fence around admission; it must invoke admit exactly once to proceed. */
   readonly embeddingAdmission?: (admit: () => Promise<void>) => Promise<void>
+  /**
+   * Accounting the execution attempt already owns, such as an Agent run's. Calls then share its
+   * admission and failure state instead of opening a second recorder for the same attempt.
+   */
+  readonly accounting?: AiModelCallRecorder
 }
 
 const bindings = new WeakMap<ModelsRuntime, (input: ModelExecutionAttempt) => void>()

package/src/models/execution/model-call-recorder.ts

@@ -70,6 +70,16 @@ export class AiModelCallRecorder {
       })
   }
 
+  /** The execution every call this recorder admits is attributed to. */
+  get executionId(): string {
+    return this.input.executionId
+  }
+
+  /** The execution attempt every call this recorder admits is attributed to. */
+  get attempt(): number {
+    return this.input.attempt
+  }
+
   /** Wrap the resolved model so all calls in an execution share admission. */
   wrapModel(model: LanguageModel): LanguageModel {
     return {

package/src/models/execution/session.ts

@@ -34,8 +34,8 @@ export class ModelExecutionSession {
   }
 
   accounting(): Promise<AiModelCallRecorder> {
-    this.requireBinding()
-    this.recorder ??= this.createRecorder()
+    const { accounting } = this.requireBinding()
+    this.recorder ??= accounting ? Promise.resolve(accounting) : this.createRecorder()
     return this.recorder
   }
 

package/src/models/execution.ts

@@ -45,6 +45,7 @@ export function createModelsRuntime(
     const messages = generationMessages(input)
     const signal = session.signal(input.signal)
     signal.throwIfAborted()
+    // The catalog's binding is the configured one, default reasoning included.
     const selected = input.model
       ? catalog
         ? catalog.language?.getByRef({
@@ -70,6 +71,9 @@ export function createModelsRuntime(
       input.reasoning
     )
     if (reasoningIssue) throw new UnsupportedModelFeatureError(`[SixbModels] ${reasoningIssue}.`)
+    // The default was checked against the capabilities known at startup; like any request, a level
+    // the resolved model turns out not to support falls back to the provider default.
+    const reasoning = input.reasoning ?? selected.defaultReasoning
     if (output && model.definition.capabilities.nativeStructuredOutput === false) {
       throw new UnsupportedModelFeatureError(
         "[SixbModels] Model does not support native structured output."
@@ -79,7 +83,7 @@ export function createModelsRuntime(
       aiModelCallOutputTokenAllowance(input.maxOutputTokens ?? model.definition.maxOutputTokens),
       model.definition.maxOutputTokens ?? Infinity
     )
-    if (typeof input.reasoning === "object" && input.reasoning.budgetTokens >= maxOutputTokens) {
+    if (typeof reasoning === "object" && reasoning.budgetTokens >= maxOutputTokens) {
       throw new TypeError("[SixbModels] Output allowance must exceed the reasoning token budget.")
     }
     const accounting = await session.accounting()
@@ -92,7 +96,7 @@ export function createModelsRuntime(
       maxSteps: 1,
       rejectLocalToolCalls: true,
       maxOutputTokens,
-      reasoning: input.reasoning,
+      reasoning,
       caching: input.caching,
       signal,
       onModelCallEnd: async (completed: ModelCallEndEvent) => {

package/src/models/language-model.ts

@@ -83,6 +83,12 @@ export interface LanguageModel {
   readonly modelId: string
   readonly definition: LanguageModelDefinition
   readonly costEstimator?: ModelCostEstimator
+  /**
+   * Reasoning Sixb applies whenever this model runs without an explicit choice: chat turns, AI
+   * workflow steps, subagents, and direct generation. Providers set it from their model options;
+   * Sixb checks it against `definition.capabilities` at startup.
+   */
+  readonly defaultReasoning?: ModelReasoningLevel
   /**
    * Return an executable model pinned to operational metadata, preserving model identity.
    * `offline` requires a local snapshot without catalog I/O. Workers retain this model

package/src/objects/action/errors.ts

@@ -42,15 +42,3 @@ export class ActionRunFailedError extends Error {
     this.finishedAt = payload.finishedAt
   }
 }
-
-export class ActionRunTimeoutError extends Error {
-  readonly name = "ActionRunTimeoutError"
-  readonly runId: string
-  readonly timeoutMs: number
-
-  constructor(params: { runId: string; timeoutMs: number }) {
-    super(`Action run '${params.runId}' did not finish within ${params.timeoutMs}ms.`)
-    this.runId = params.runId
-    this.timeoutMs = params.timeoutMs
-  }
-}

package/src/objects/action/index.ts

@@ -1,3 +1,3 @@
-export { ActionRunFailedError, ActionRunTimeoutError, ActionValidationError } from "./errors"
-export type { RequestActionAndWaitOptions, RequestActionOptions } from "./request"
-export { requestAction, requestActionAndWait } from "./request"
+export { ActionRunFailedError, ActionValidationError } from "./errors"
+export type { RequestActionOptions } from "./request"
+export { requestAction } from "./request"

package/src/objects/action/request.ts

@@ -5,16 +5,13 @@
  * helpers delegate here by supplying an object subject.
  */
 import {
-  type RequestActionAndWaitOptions,
   type RequestActionOptions,
-  type RequestActionResult,
   requestAction as requestRuntimeAction,
-  requestActionAndWait as requestRuntimeActionAndWait,
 } from "../../actions/request"
 import type { ActionRunRecord } from "../../storage"
 import type { ExecutionObjectContext } from "../context"
 
-export type { RequestActionAndWaitOptions, RequestActionOptions }
+export type { RequestActionOptions }
 
 export async function requestAction(
   ctx: ExecutionObjectContext,
@@ -24,30 +21,8 @@ export async function requestAction(
     params?: Record<string, unknown>
     options?: RequestActionOptions
   }
-): Promise<RequestActionResult> {
-  return requestRuntimeAction(ctx, ctx.execution, {
-    actionId: params.actionId,
-    subject: {
-      kind: "object",
-      objectTypeId: ctx.objectType.id,
-      primaryId: params.primaryId,
-    },
-    params: params.params,
-    runId: params.options?.runId,
-    signal: params.options?.signal,
-  })
-}
-
-export async function requestActionAndWait(
-  ctx: ExecutionObjectContext,
-  params: {
-    primaryId: string
-    actionId: string
-    params?: Record<string, unknown>
-    options?: RequestActionAndWaitOptions
-  }
 ): Promise<ActionRunRecord> {
-  return requestRuntimeActionAndWait(ctx, ctx.execution, {
+  return requestRuntimeAction(ctx, ctx.execution, {
     actionId: params.actionId,
     subject: {
       kind: "object",
@@ -56,8 +31,6 @@ export async function requestActionAndWait(
     },
     params: params.params,
     runId: params.options?.runId,
-    timeoutMs: params.options?.timeoutMs,
     signal: params.options?.signal,
-    onRequested: params.options?.onRequested,
   })
 }

package/src/objects/context/index.ts

@@ -1,6 +1,7 @@
 export { requireLinkDefinition, resolveLinkContext, resolveObjectContext } from "./resolve"
 export type {
   ExecutionObjectContext,
+  ObjectSetContext,
   ResolvedLinkBatchItem,
   ResolvedLinkContext,
   ResolvedObjectContext,