@sixb/core 0.1.18 → 0.1.19

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

@@ -1,3 +1,4 @@
+import { shareActionRunExecutor } from "../actions/run/executor"
 import type { BlobStorage } from "../blob-storage"
 import { shareSixbErrorReporter } from "../error-reporting/capability"
 import type { ExecutionContext } from "../execution"
@@ -86,7 +87,6 @@ export interface ExecutionObjectByIdHandle<TObjectType extends ObjectTypeWithPro
   extends ObjectReadByIdHandle<TObjectType> {
   vector: ObjectByIdHandle<TObjectType>["vector"]
   requestAction: ObjectByIdHandle<TObjectType>["requestAction"]
-  requestActionAndWait: ObjectByIdHandle<TObjectType>["requestActionAndWait"]
   link: ObjectByIdHandle<TObjectType>["link"]
   unlink: ObjectByIdHandle<TObjectType>["unlink"]
   delete: ObjectByIdHandle<TObjectType>["delete"]
@@ -97,7 +97,6 @@ export interface ExecutionObjectByIdHandle<TObjectType extends ObjectTypeWithPro
 export interface ExecutionObjectSet<TObjectType extends ObjectTypeWithPropertyTokens>
   extends ObjectReadSet<TObjectType> {
   requestAction: ObjectSet<TObjectType>["requestAction"]
-  requestActionAndWait: ObjectSet<TObjectType>["requestActionAndWait"]
   upsert: ObjectSet<TObjectType>["upsert"]
   upsertLink: ObjectSet<TObjectType>["upsertLink"]
   removeLink: ObjectSet<TObjectType>["removeLink"]
@@ -173,6 +172,7 @@ export function createObjectsRuntime(
   }
   shareOntologyMutationRuntime(runtime, capturedRuntime)
   shareSixbErrorReporter(runtime, capturedRuntime)
+  shareActionRunExecutor(runtime, capturedRuntime)
   Object.freeze(capturedRuntime)
   const ontologyView = () => getAuthorizedOntologyView(objectReader)
   const objects = Object.assign(

package/src/objects/sdk/object-handle.ts

@@ -10,10 +10,7 @@ import { OntologyValidationError } from "../../ontology/errors"
 import type { LinkToken, ObjectTypeWithPropertyTokens, PropertyToken } from "../../ontology/tokens"
 import { assertLinkTokenBelongsToObjectType } from "../../ontology/validation"
 import type { ObjectByIdHandle, TwinObject } from "../../runtime/types"
-import {
-  requestActionAndWait as requestActionAndWaitLeaf,
-  requestAction as requestActionLeaf,
-} from "../action"
+import { requestAction as requestActionLeaf } from "../action"
 import type { ObjectSetContext, ResolvedLinkContext } from "../context"
 import { removeLink as removeLinkLeaf, upsertLink as upsertLinkLeaf } from "../link"
 import { deleteObject, restoreObject } from "../object"
@@ -91,6 +88,7 @@ export function createObjectByIdHandle<TObjectType extends ObjectTypeWithPropert
       actionId?: string
       params?: Record<string, unknown>
       runId?: string
+      signal?: AbortSignal
     }) => {
       const actionId = input.action?.id ?? input.actionId
       if (!actionId) {
@@ -102,31 +100,7 @@ export function createObjectByIdHandle<TObjectType extends ObjectTypeWithPropert
         primaryId,
         actionId,
         params: input.params,
-        options: { runId: input.runId },
-      })
-    },
-
-    requestActionAndWait: async (input: {
-      action?: ActionDefinition
-      actionId?: string
-      params?: Record<string, unknown>
-      timeoutMs?: number
-      signal?: AbortSignal
-    }) => {
-      const actionId = input.action?.id ?? input.actionId
-      if (!actionId) {
-        throw new OntologyValidationError(
-          "[Sixb] requestActionAndWait requires either 'action' or 'actionId'"
-        )
-      }
-      return requestActionAndWaitLeaf(ctx, {
-        primaryId,
-        actionId,
-        params: input.params,
-        options: {
-          timeoutMs: input.timeoutMs,
-          signal: input.signal,
-        },
+        options: { runId: input.runId, signal: input.signal },
       })
     },
 

package/src/objects/sdk/object-set.ts

@@ -5,6 +5,7 @@
  */
 
 import type { ActionDefinition } from "../../actions"
+import { shareActionRunExecutor } from "../../actions/run/executor"
 import type { AuthorizationContext } from "../../authorization"
 import type { BlobStorage } from "../../blob-storage"
 import { shareSixbErrorReporter } from "../../error-reporting/capability"
@@ -19,10 +20,7 @@ import type {
   SixbRuntimeContext,
   TwinObject,
 } from "../../runtime/types"
-import {
-  requestActionAndWait as requestActionAndWaitLeaf,
-  requestAction as requestActionLeaf,
-} from "../action"
+import { requestAction as requestActionLeaf } from "../action"
 import type { ObjectSetContext, ResolvedLinkContext } from "../context"
 import { requireLinkDefinition } from "../context"
 import { removeLink as removeLinkLeaf, upsertLink as upsertLinkLeaf } from "../link"
@@ -88,6 +86,7 @@ export function createObjectSet<TObjectType extends ObjectTypeWithPropertyTokens
   }
   shareOntologyMutationRuntime(params, resolvedCtx)
   shareSixbErrorReporter(params, resolvedCtx)
+  shareActionRunExecutor(params, resolvedCtx)
 
   const objectSet = {
     get: async (id: string) => {
@@ -149,6 +148,7 @@ export function createObjectSet<TObjectType extends ObjectTypeWithPropertyTokens
       actionId?: string
       params?: Record<string, unknown>
       runId?: string
+      signal?: AbortSignal
     }) => {
       const actionId = input.action?.id ?? input.actionId
       if (!actionId) {
@@ -160,32 +160,7 @@ export function createObjectSet<TObjectType extends ObjectTypeWithPropertyTokens
         primaryId: input.id,
         actionId,
         params: input.params,
-        options: { runId: input.runId },
-      })
-    },
-
-    requestActionAndWait: async (input: {
-      id: string
-      action?: ActionDefinition
-      actionId?: string
-      params?: Record<string, unknown>
-      timeoutMs?: number
-      signal?: AbortSignal
-    }) => {
-      const actionId = input.action?.id ?? input.actionId
-      if (!actionId) {
-        throw new OntologyValidationError(
-          "[Sixb] requestActionAndWait requires either 'action' or 'actionId'"
-        )
-      }
-      return requestActionAndWaitLeaf(resolvedCtx, {
-        primaryId: input.id,
-        actionId,
-        params: input.params,
-        options: {
-          timeoutMs: input.timeoutMs,
-          signal: input.signal,
-        },
+        options: { runId: input.runId, signal: input.signal },
       })
     },
 

package/src/objects/service/index.ts

@@ -1,4 +1,3 @@
-export { requestAction, requestActionAndWait } from "./action-service"
 export { removeLink, upsertLink, upsertLinkBatch } from "./link-service"
 export type { ListObjectsParams } from "./list-service"
 export { listObjects } from "./list-service"

package/src/queues/in-memory.ts

@@ -3,8 +3,6 @@ import type { SixbErrorCode } from "../errors/types"
 import { QueueError } from "./errors"
 import { IndexedHeap } from "./indexed-heap"
 import type {
-  ActionQueueJobFailureCode,
-  ActionRunRequestedQueueJob,
   AgentQueueJob,
   AgentQueueJobFailureCode,
   ClaimedQueueJob,
@@ -458,10 +456,6 @@ export class InMemoryQueues implements Queues {
     this.store,
     "workflow.runs"
   )
-  readonly actions = new InMemoryQueue<ActionRunRequestedQueueJob, ActionQueueJobFailureCode>(
-    this.store,
-    "action.runs"
-  )
   readonly agents = new InMemoryQueue<AgentQueueJob, AgentQueueJobFailureCode>(
     this.store,
     "agent.runs"

package/src/queues/index.ts

@@ -15,8 +15,6 @@ export type { ProviderScope } from "../provider-scope"
 export { QueueError } from "./errors"
 export { InMemoryQueues } from "./in-memory"
 export type {
-  ActionQueueJobFailureCode,
-  ActionRunRequestedQueueJob,
   AgentAiUsageRecordRequestedQueueJob,
   AgentQueueJob,
   AgentQueueJobFailureCode,

package/src/queues/types.ts

@@ -6,7 +6,6 @@ import type {
 } from "../models/execution/types"
 import type { ProjectionRunFailureCode } from "../projections/types"
 import type { ProviderScope } from "../provider-scope"
-import type { ActionRunFailureCode } from "../storage/action-runs/types"
 import type { AgentRunFailureCode } from "../storage/agents/types"
 import type { PipelineRunFailureCode } from "../storage/pipeline-runs/types"
 import type { SyncRunFailureCode } from "../storage/sync-runs/types"
@@ -48,7 +47,6 @@ export type SyncQueueJobFailureCode = SyncRunFailureCode
 export type PipelineQueueJobFailureCode = PipelineRunFailureCode
 export type ProjectionQueueJobFailureCode = ProjectionRunFailureCode
 export type WorkflowQueueJobFailureCode = WorkflowRunFailureCode
-export type ActionQueueJobFailureCode = ActionRunFailureCode
 export type AgentQueueJobFailureCode = AgentRunFailureCode
 
 export interface ClaimedQueueJob<TQueueJob extends QueueJob = QueueJob> {
@@ -176,14 +174,6 @@ export interface WorkflowRunResumeRequestedQueueJob
 
 export type WorkflowQueueJob = WorkflowRunRequestedQueueJob | WorkflowRunResumeRequestedQueueJob
 
-export interface ActionRunRequestedQueueJob
-  extends QueueJob<
-    "action.run.requested",
-    {
-      readonly runId: string
-    }
-  > {}
-
 /**
  * An agent turn is requested for a thread. The payload points to the durable queued run created
  * with the user message; the worker transitions it to running and installs the delivery's execution
@@ -245,7 +235,6 @@ export interface Queues {
   readonly pipelines: Queue<PipelineRunRequestedQueueJob, PipelineQueueJobFailureCode>
   readonly projections: Queue<ProjectionRunRequestedQueueJob, ProjectionQueueJobFailureCode>
   readonly workflows: Queue<WorkflowQueueJob, WorkflowQueueJobFailureCode>
-  readonly actions: Queue<ActionRunRequestedQueueJob, ActionQueueJobFailureCode>
   readonly agents: Queue<AgentQueueJob, AgentQueueJobFailureCode>
   /** Internal capacity reserved for headless child runs. */
   readonly agentChildren: Queue<SubagentQueueJob, AgentQueueJobFailureCode>

package/src/runtime/host.ts

@@ -6,6 +6,7 @@
  */
 
 import { resolve } from "node:path"
+import { ActionRunExecutor, registerActionRunExecutor } from "../actions/run/executor"
 import type { ActionDefinition } from "../actions/types"
 import type { AgentDefinitionsInput, AgentToolDefinition } from "../agents"
 import {
@@ -294,6 +295,10 @@ export class SixbHost<in out TParams extends ParamsConfig = ParamsConfig> {
     }
     registerProjectionRegistry(this.hostContext, definitions.projections)
     shareSixbErrorReporter(this, this.hostContext)
+    // Bound SDKs run requested Actions through the context; the host drains them on shutdown.
+    const executor = new ActionRunExecutor(this)
+    registerActionRunExecutor(this, executor)
+    registerActionRunExecutor(this.hostContext, executor)
     registerVectorIndexingRuntime(
       this,
       createVectorIndexingRuntime(this.hostContext, this.materializer)

package/src/runtime/resolve-definitions.ts

@@ -145,7 +145,6 @@ export function resolveDefinitions(options: DefinitionOptions): ResolvedDefiniti
 
   validateSchedulesAtStartup(schedules, ontology, {
     registeredRuleIds: new Set(rulesById.keys()),
-    registeredActionIds,
     registeredDatasetIds: new Set(datasetsById.keys()),
     registeredSyncIds: new Set(syncsById.keys()),
     registeredPipelineIds: new Set(pipelinesById.keys()),

package/src/runtime/types.ts

@@ -5,12 +5,7 @@
  * Each level narrows generic parameters so downstream code stays type-safe.
  */
 
-import type {
-  ActionDefinitionCatalog,
-  ActionParamsConfig,
-  InferActionParams,
-  RequestActionResult,
-} from "../actions"
+import type { ActionDefinitionCatalog, ActionParamsConfig, InferActionParams } from "../actions"
 import type { AuthorizationContext } from "../authorization"
 import type { OpenedFileRef } from "../blob-storage"
 import type { Broker } from "../broker"
@@ -860,36 +855,25 @@ export interface ObjectByIdHandle<TObjectType extends ObjectTypeWithPropertyToke
     target: ObjectRef<ResolveTargetTypeId<TLinkToken["targetObjectTypeId"]>>
   ): Promise<void>
 
-  /** Request an action on this object by id (dynamic / server contexts). */
+  /**
+   * Run an action on this object by id (dynamic / server contexts) and return its terminal run.
+   * A failed run resolves with status `failed`.
+   */
   requestAction(input: {
     actionId: string
     params?: Record<string, unknown>
     runId?: string
-  }): Promise<RequestActionResult>
+    signal?: AbortSignal
+  }): Promise<ActionRunRecord>
 
   /**
-   * Request an action on this object using a typed action reference.
+   * Run an action on this object using a typed action reference, and return its terminal run.
    * Params are inferred from the action's declared shape.
    */
   requestAction<const TAction extends TypedActionReference>(input: {
     action: TAction
     params: NoInfer<TypedActionParams<TAction>>
     runId?: string
-  }): Promise<RequestActionResult>
-
-  /** Request an action and wait for the terminal lifecycle event. */
-  requestActionAndWait(input: {
-    actionId: string
-    params?: Record<string, unknown>
-    timeoutMs?: number
-    signal?: AbortSignal
-  }): Promise<ActionRunRecord>
-
-  /** Request a typed action and wait for the terminal lifecycle event. */
-  requestActionAndWait<const TAction extends TypedActionReference>(input: {
-    action: TAction
-    params: NoInfer<TypedActionParams<TAction>>
-    timeoutMs?: number
     signal?: AbortSignal
   }): Promise<ActionRunRecord>
 
@@ -931,40 +915,27 @@ export interface ObjectSet<TObjectType extends ObjectTypeWithPropertyTokens>
     }[]
   ): Promise<void>
 
-  /** Request an action on an object of this type by id (dynamic / server contexts). */
+  /**
+   * Run an action on an object of this type by id (dynamic / server contexts) and return its
+   * terminal run. A failed run resolves with status `failed`.
+   */
   requestAction(input: {
     id: string
     actionId: string
     params?: Record<string, unknown>
     runId?: string
-  }): Promise<RequestActionResult>
+    signal?: AbortSignal
+  }): Promise<ActionRunRecord>
 
   /**
-   * Request an action on an object of this type using a typed action reference.
-   * Params are inferred from the action's declared shape.
+   * Run an action on an object of this type using a typed action reference, and return its
+   * terminal run. Params are inferred from the action's declared shape.
    */
   requestAction<const TAction extends TypedActionReference>(input: {
     id: string
     action: TAction
     params: NoInfer<TypedActionParams<TAction>>
     runId?: string
-  }): Promise<RequestActionResult>
-
-  /** Request an action on an object and wait for the terminal lifecycle event. */
-  requestActionAndWait(input: {
-    id: string
-    actionId: string
-    params?: Record<string, unknown>
-    timeoutMs?: number
-    signal?: AbortSignal
-  }): Promise<ActionRunRecord>
-
-  /** Request a typed action and wait for the terminal lifecycle event. */
-  requestActionAndWait<const TAction extends TypedActionReference>(input: {
-    id: string
-    action: TAction
-    params: NoInfer<TypedActionParams<TAction>>
-    timeoutMs?: number
     signal?: AbortSignal
   }): Promise<ActionRunRecord>
 

package/src/schedules/builders.ts

@@ -169,9 +169,6 @@ function assertEventSource(source: EventSelectorSpec): void {
     case "rules":
       assertNonEmpty(source.ruleId ?? "", "event source ruleId")
       return
-    case "actions":
-      assertNonEmpty(source.actionId ?? "", "event source actionId")
-      return
     case "datasets":
       assertNonEmpty(source.datasetId ?? "", "event source datasetId")
       return
@@ -183,7 +180,7 @@ function assertEventSource(source: EventSelectorSpec): void {
       return
     default:
       throw new ScheduleValidationError(
-        "Schedule event source must select object, link, rule, action, dataset, sync, or pipeline events."
+        "Schedule event source must select object, link, rule, dataset, sync, or pipeline events."
       )
   }
 }