@sixb/core 0.1.18 → 0.1.20

package/src/events/selectors/types.ts

@@ -1,13 +1,6 @@
-import type {
-  ActionBinding,
-  ActionDefinition,
-  ActionParamsConfig,
-  InferActionParams,
-} from "../../actions"
 import type { LinkToken, ObjectRef, ObjectTypeWithTokens, Property } from "../../ontology"
 import type { InferPropertyValue } from "../../ontology/inference"
 import type { RuleDefinition } from "../../rules"
-import type { ActionRunFailure } from "../../storage"
 import type { PropertyChangeOperation } from "../property-changes"
 import type {
   DatasetVersionCommittedEvent,
@@ -45,33 +38,6 @@ export type RuleEventSelectorContext<
   readonly operation: TOperation
 }
 
-export type ActionEventSelectorOperation = "requested" | "completed" | "failed"
-
-export type ActionEventToken<
-  TId extends string = string,
-  TParams extends ActionParamsConfig = ActionParamsConfig,
-  TBinding extends ActionBinding = ActionBinding,
-> = {
-  readonly id: TId
-  readonly params: TParams
-  readonly binding: TBinding
-}
-
-export type ActionEventTokenOf<TAction extends ActionDefinition> = ActionEventToken<
-  TAction["id"],
-  TAction["params"],
-  TAction["binding"]
->
-
-export type ActionEventSelectorContext<
-  TAction extends ActionEventToken = ActionEventToken,
-  TOperation extends ActionEventSelectorOperation = ActionEventSelectorOperation,
-> = {
-  readonly kind: "action"
-  readonly action: TAction
-  readonly operation: TOperation
-}
-
 export type DatasetEventToken<TId extends string = string> = {
   readonly kind: "dataset"
   readonly id: TId
@@ -116,7 +82,6 @@ export type EventSelectorContext =
   | ObjectEventSelectorContext
   | LinkEventSelectorContext
   | RuleEventSelectorContext
-  | ActionEventSelectorContext
   | DatasetEventSelectorContext
   | SyncEventSelectorContext
   | PipelineEventSelectorContext
@@ -138,15 +103,13 @@ export type EventSelectorEvent<TContext> =
       ? LinkEventSelectorEvent<TObjectType, TLink>
       : TContext extends RuleEventSelectorContext<infer TRule, infer TOperation>
         ? RuleEventSelectorEvent<TRule, TOperation>
-        : TContext extends ActionEventSelectorContext<infer TAction, infer TOperation>
-          ? ActionEventSelectorEvent<TAction, TOperation>
-          : TContext extends DatasetEventSelectorContext<infer TDataset>
-            ? DatasetEventSelectorEvent<TDataset>
-            : TContext extends SyncEventSelectorContext<infer TSync, infer TOperation>
-              ? SyncEventSelectorEvent<TSync, TOperation>
-              : TContext extends PipelineEventSelectorContext<infer TPipeline, infer TOperation>
-                ? PipelineEventSelectorEvent<TPipeline, TOperation>
-                : never
+        : TContext extends DatasetEventSelectorContext<infer TDataset>
+          ? DatasetEventSelectorEvent<TDataset>
+          : TContext extends SyncEventSelectorContext<infer TSync, infer TOperation>
+            ? SyncEventSelectorEvent<TSync, TOperation>
+            : TContext extends PipelineEventSelectorContext<infer TPipeline, infer TOperation>
+              ? PipelineEventSelectorEvent<TPipeline, TOperation>
+              : never
 
 export interface ObjectEventSelectorEvent<TObjectType extends ObjectTypeWithTokens> {
   readonly object: {
@@ -176,19 +139,6 @@ export type RuleEventSelectorEvent<
   readonly subject: ObjectRef<RuleSubjectTypeId<TRule>>
 }
 
-export type ActionEventSelectorEvent<
-  TAction extends ActionEventToken = ActionEventToken,
-  TOperation extends ActionEventSelectorOperation = ActionEventSelectorOperation,
-> = {
-  readonly actionId: TAction["id"]
-  readonly runId: string
-} & ActionSubjectEvent<TAction> &
-  (TOperation extends "requested"
-    ? { readonly params: InferActionParams<TAction["params"]> }
-    : TOperation extends "failed"
-      ? { readonly error: ActionRunFailure }
-      : Record<never, never>)
-
 export type DatasetEventSelectorEvent<TDataset extends DatasetEventToken = DatasetEventToken> =
   Omit<DatasetVersionCommittedEvent["payload"], "datasetId"> & {
     readonly datasetId: TDataset["id"]
@@ -220,7 +170,6 @@ export interface EventSelectorSpec<TContext = EventSelectorContext> {
   readonly propertyOperation?: PropertyChangeOperation
   readonly linkId?: string
   readonly ruleId?: string
-  readonly actionId?: string
   readonly datasetId?: string
   readonly syncId?: string
   readonly pipelineId?: string
@@ -249,10 +198,3 @@ type ResolveTargetTypeId<TTarget> = TTarget extends readonly string[]
 
 type RuleSubjectTypeId<TRule extends RuleDefinition> =
   TRule extends RuleDefinition<string, infer TObjectType> ? TObjectType["id"] : string
-
-type ActionSubjectEvent<TAction extends ActionEventToken> = TAction["binding"] extends {
-  readonly kind: "object"
-  readonly objectType: infer TObjectType extends { readonly id: string }
-}
-  ? { readonly subject: ObjectRef<TObjectType["id"]> }
-  : Record<never, never>

package/src/events/types/index.ts

@@ -1,7 +1,6 @@
 import type { JsonValue } from "../../json"
 import type { OntologyMaterializationEvent } from "../../materialization/events"
 import type { EventOrigin } from "../envelope"
-import type { ActionEvent } from "./actions"
 import type { DatasetEvent } from "./datasets"
 import type { LinkEvent } from "./links"
 import type { ObjectEvent } from "./objects"
@@ -28,12 +27,6 @@ export type {
   PropertyChangeMap,
   PropertyChangeOperation,
 } from "../property-changes"
-export type {
-  ActionCompletedEvent,
-  ActionEvent,
-  ActionFailedEvent,
-  ActionRequestedEvent,
-} from "./actions"
 export type { DatasetEvent, DatasetVersionCommittedEvent } from "./datasets"
 export type {
   LinkCreatedEvent,
@@ -82,7 +75,6 @@ export type DomainEvent =
   | ObjectEvent
   | TelemetryEvent
   | LinkEvent
-  | ActionEvent
   | ScheduleEvent
   | RuleEvent
   | SyncEvent
@@ -129,9 +121,6 @@ export type StoredLinkCreatedEvent = StoredOntologyEventOf<"link.created">
 export type StoredLinkUpdatedEvent = StoredOntologyEventOf<"link.updated">
 export type StoredLinkMutationEvent = StoredLinkCreatedEvent | StoredLinkUpdatedEvent
 export type StoredLinkDeletedEvent = StoredOntologyEventOf<"link.deleted">
-export type StoredActionRequestedEvent = Extract<StoredDomainEvent, { type: "action.requested" }>
-export type StoredActionCompletedEvent = Extract<StoredDomainEvent, { type: "action.completed" }>
-export type StoredActionFailedEvent = Extract<StoredDomainEvent, { type: "action.failed" }>
 export type StoredScheduleTriggeredEvent = Extract<
   StoredDomainEvent,
   { type: "schedule.triggered" }

package/src/execution/authorization.ts

@@ -1,7 +1,12 @@
 import { isDeepStrictEqual } from "node:util"
 import { agentServiceAccountId } from "../agents/identity"
 import type { Principal } from "../auth"
-import { TARGETED_GRANT_KIND_KEYS, type TargetedGrantKind } from "../authorization/grant-kinds"
+import {
+  SINGLETON_GRANT_KIND_KEYS,
+  type SingletonGrantKind,
+  TARGETED_GRANT_KIND_KEYS,
+  type TargetedGrantKind,
+} from "../authorization/grant-kinds"
 import type { AuthorizationContext, GrantIndex } from "../authorization/types"
 import { createSixbError } from "../errors/internal"
 import type { ObjectRef } from "../ontology"
@@ -586,10 +591,11 @@ function snapshotAuthorizationContext(
   for (const kind of TARGETED_GRANT_KIND_KEYS) {
     grants[kind] = new ImmutableGrantSet(context.grants[kind])
   }
-  const frozenGrants: GrantIndex = Object.freeze({
-    ...grants,
-    "run:agent": context.grants["run:agent"],
-  })
+  const singletons = {} as Record<SingletonGrantKind, boolean>
+  for (const kind of SINGLETON_GRANT_KIND_KEYS) {
+    singletons[kind] = context.grants[kind]
+  }
+  const frozenGrants: GrantIndex = Object.freeze({ ...grants, ...singletons })
   return Object.freeze({
     principal,
     ...(context.sessionId === undefined ? {} : { sessionId: context.sessionId }),

package/src/index.ts

@@ -116,12 +116,8 @@ export type {
   ObjectActionDefinition,
   ObjectActionParamsBuilder,
   ObjectActionPhaseBuilder,
-  RequestActionAndWaitInput,
-  RequestActionAndWaitOptions,
   RequestActionInput,
   RequestActionOptions,
-  RequestActionResult,
-  WaitForActionRunInput,
 } from "./actions"
 export {
   ActionDefinitionError,
@@ -137,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 ────────────────────────────────────────────────
 
@@ -233,17 +225,7 @@ export type {
 // ── Events ──────────────────────────────────────────────────
 
 export type {
-  ActionCompletedEvent,
-  ActionEvent,
   ActionEventOrigin,
-  ActionEventSelectorBuilder,
-  ActionEventSelectorContext,
-  ActionEventSelectorEvent,
-  ActionEventSelectorOperation,
-  ActionEventToken,
-  ActionEventTokenOf,
-  ActionFailedEvent,
-  ActionRequestedEvent,
   DatasetEvent,
   DatasetEventSelectorBuilder,
   DatasetEventSelectorContext,
@@ -409,8 +391,6 @@ export {
 
 export type {
   AuthCookieOptions,
-  AuthSessionAudience,
-  AuthSessionAudienceOptions,
   AuthSessionOptions,
   AuthStrategy,
   AuthStrategyKind,
@@ -419,22 +399,14 @@ export type {
   Principal,
   SixbAuthConfig,
 } from "./auth"
-export {
-  DEFAULT_AUTH_SESSION_AUDIENCE,
-  isValidAuthSessionAudience,
-  principalsEqual,
-  resolveAuthSessionAudience,
-  SYSTEM_PRINCIPAL,
-} from "./auth"
+export { principalsEqual, SYSTEM_PRINCIPAL } from "./auth"
 
 // ── Authorization ──────────────────────────────────────────
 
 export type { AuthorizationContext, GrantIndex, GrantKind } from "./authorization"
 export {
   AuthorizationError,
-  canAccessApplication,
   isAllowed,
-  isApplicationAccessControlled,
   resolveAuthorizationContext,
 } from "./authorization"
 
@@ -458,10 +430,8 @@ export type {
 // ── Security Definitions ───────────────────────────────────
 
 export type {
-  AccessGrant,
   AgentRunGrant,
   AppendGrant,
-  ApplicationDefinition,
   ApplyGrant,
   BreadthSelector,
   BreadthTarget,
@@ -494,7 +464,6 @@ export type {
   ViewGrantTarget,
 } from "./security"
 export {
-  applications,
   can,
   defineGroup,
   defineMarking,

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/execution/embedding.ts

@@ -58,9 +58,9 @@ async function executeEmbedding(
   if (purpose !== undefined && purpose !== "document" && purpose !== "query") {
     throw new TypeError("[SixbModels] Embedding purpose must be 'document' or 'query'.")
   }
+  // The caller owns the deadline: only it knows whether anyone is waiting for the result.
   const signal = session.signal(input.signal)
-  const requestSignal = AbortSignal.any([signal, AbortSignal.timeout(30_000)])
-  requestSignal.throwIfAborted()
+  signal.throwIfAborted()
   if (!texts.length) return { vectors: [] }
 
   const accounting = await session.accounting()
@@ -72,7 +72,7 @@ async function executeEmbedding(
       "[SixbModels] Resolved embedding model identity does not match the selected model."
     )
   }
-  requestSignal.throwIfAborted()
+  signal.throwIfAborted()
   const callId = `call_${randomUUID()}`
   const tokens = texts.reduce(
     (sum, text) => sum + Math.ceil(new TextEncoder().encode(text).byteLength / 4),
@@ -92,8 +92,8 @@ async function executeEmbedding(
 
   let result: EmbeddingModelResult
   try {
-    requestSignal.throwIfAborted()
-    result = await model.embed({ texts, purpose, signal: requestSignal })
+    signal.throwIfAborted()
+    result = await model.embed({ texts, purpose, signal })
   } catch (error) {
     if (error instanceof EmbeddingModelResponseError) {
       await recordEmbedding(accounting, model, callId, error.metadata)
@@ -105,7 +105,7 @@ async function executeEmbedding(
   }
   // Account before cancellation, vector validation or the materializer's optimistic write.
   await recordEmbedding(accounting, model, callId, result ?? {})
-  requestSignal.throwIfAborted()
+  signal.throwIfAborted()
   return result
 }
 

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,
   })
 }