@valon-technologies/gestalt 0.0.1-alpha.32 → 0.0.1-alpha.34

package/src/workflow.ts

@@ -6,90 +6,104 @@ import {
   type ServiceImpl,
 } from "@connectrpc/connect";
 
+import type { AgentOutput, AgentToolRef } from "./agent.ts";
+import {
+  agentOutputFromProto,
+  agentOutputToProto,
+  agentToolRefFromProto,
+  agentToolRefToProto,
+} from "./agent-conversions.ts";
+import {
+  type MaybePromise,
+  type Request,
+  type Subject,
+  type SubjectInput,
+  errorMessage,
+} from "./api.ts";
+import { SubjectContextSchema, type SubjectContext } from "./internal/gen/v1/app_pb.ts";
 import {
-  BoundWorkflowDefinitionSchema,
-  BoundWorkflowEventTriggerSchema,
-  BoundWorkflowRunSchema,
-  BoundWorkflowScheduleSchema,
+  ApplyWorkflowProviderDefinitionRequestSchema,
   BoundWorkflowTargetSchema,
-  ListWorkflowProviderEventTriggersResponseSchema,
+  CancelWorkflowProviderRunRequestSchema,
+  DeliverWorkflowProviderEventRequestSchema,
+  GetWorkflowProviderRunEventsResponseSchema,
+  GetWorkflowProviderRunOutputResponseSchema,
+  ListWorkflowProviderDefinitionsResponseSchema,
   ListWorkflowProviderRunsResponseSchema,
-  ListWorkflowProviderSchedulesResponseSchema,
   SignalWorkflowRunResponseSchema,
-  WorkflowActorSchema,
+  WorkflowActivationSchema,
+  WorkflowAgentMessageSchema,
+  WorkflowArraySchema,
+  WorkflowDefinitionSchema,
+  WorkflowDefinitionSpecSchema,
+  WorkflowEventActivationSchema,
   WorkflowEventMatchSchema,
   WorkflowEventSchema,
   WorkflowEventTriggerInvocationSchema,
   WorkflowManualTriggerSchema,
-  WorkflowAgentMessageSchema,
-  WorkflowArraySchema,
   WorkflowObjectSchema,
   WorkflowPathSourceSchema,
   WorkflowProvider as WorkflowProviderService,
+  WorkflowRunEventSchema,
+  WorkflowRunSchema,
   WorkflowRunStatus as ProtoWorkflowRunStatus,
   WorkflowRunTriggerSchema,
+  WorkflowScheduleActivationSchema,
   WorkflowScheduleTriggerSchema,
   WorkflowSignalSchema,
-  type BoundWorkflowDefinition as ProtoBoundWorkflowDefinition,
-  type BoundWorkflowEventTrigger as ProtoBoundWorkflowEventTrigger,
-  type BoundWorkflowRun as ProtoBoundWorkflowRun,
-  type BoundWorkflowSchedule as ProtoBoundWorkflowSchedule,
+  WorkflowStepAgentTurnSchema,
+  WorkflowStepAppCallSchema,
+  WorkflowStepAttemptSchema,
+  WorkflowStepExecutionSchema,
+  WorkflowStepInputSourceSchema,
+  WorkflowStepOutputSourceSchema,
+  WorkflowStepSchema,
+  WorkflowStepStatus as ProtoWorkflowStepStatus,
+  WorkflowStepWhenSchema,
+  WorkflowTextSchema,
+  WorkflowValueSchema,
+  type ApplyWorkflowProviderDefinitionRequest as ProtoApplyWorkflowProviderDefinitionRequest,
   type BoundWorkflowTarget as ProtoBoundWorkflowTarget,
   type CancelWorkflowProviderRunRequest as ProtoCancelWorkflowProviderRunRequest,
-  type CreateWorkflowProviderDefinitionRequest as ProtoCreateWorkflowProviderDefinitionRequest,
-  type DeleteWorkflowProviderDefinitionRequest as ProtoDeleteWorkflowProviderDefinitionRequest,
-  type DeleteWorkflowProviderEventTriggerRequest as ProtoDeleteWorkflowProviderEventTriggerRequest,
-  type DeleteWorkflowProviderScheduleRequest as ProtoDeleteWorkflowProviderScheduleRequest,
+  type DeliverWorkflowProviderEventRequest as ProtoDeliverWorkflowProviderEventRequest,
   type GetWorkflowProviderDefinitionRequest as ProtoGetWorkflowProviderDefinitionRequest,
-  type GetWorkflowProviderEventTriggerRequest as ProtoGetWorkflowProviderEventTriggerRequest,
+  type GetWorkflowProviderRunEventsRequest as ProtoGetWorkflowProviderRunEventsRequest,
+  type GetWorkflowProviderRunOutputRequest as ProtoGetWorkflowProviderRunOutputRequest,
+  type GetWorkflowProviderRunOutputResponse as ProtoGetWorkflowProviderRunOutputResponse,
   type GetWorkflowProviderRunRequest as ProtoGetWorkflowProviderRunRequest,
-  type GetWorkflowProviderScheduleRequest as ProtoGetWorkflowProviderScheduleRequest,
-  type ListWorkflowProviderEventTriggersRequest as ProtoListWorkflowProviderEventTriggersRequest,
+  type ListWorkflowProviderDefinitionsRequest as ProtoListWorkflowProviderDefinitionsRequest,
   type ListWorkflowProviderRunsRequest as ProtoListWorkflowProviderRunsRequest,
-  type ListWorkflowProviderSchedulesRequest as ProtoListWorkflowProviderSchedulesRequest,
-  type PauseWorkflowProviderEventTriggerRequest as ProtoPauseWorkflowProviderEventTriggerRequest,
-  type PauseWorkflowProviderScheduleRequest as ProtoPauseWorkflowProviderScheduleRequest,
-  type PublishWorkflowProviderEventRequest as ProtoPublishWorkflowProviderEventRequest,
-  type ResumeWorkflowProviderEventTriggerRequest as ProtoResumeWorkflowProviderEventTriggerRequest,
-  type ResumeWorkflowProviderScheduleRequest as ProtoResumeWorkflowProviderScheduleRequest,
+  type SetWorkflowProviderActivationPausedRequest as ProtoSetWorkflowProviderActivationPausedRequest,
+  type SetWorkflowProviderDefinitionPausedRequest as ProtoSetWorkflowProviderDefinitionPausedRequest,
   type SignalOrStartWorkflowProviderRunRequest as ProtoSignalOrStartWorkflowProviderRunRequest,
   type SignalWorkflowProviderRunRequest as ProtoSignalWorkflowProviderRunRequest,
   type SignalWorkflowRunResponse as ProtoSignalWorkflowRunResponse,
   type StartWorkflowProviderRunRequest as ProtoStartWorkflowProviderRunRequest,
-  type UpdateWorkflowProviderDefinitionRequest as ProtoUpdateWorkflowProviderDefinitionRequest,
-  type UpsertWorkflowProviderEventTriggerRequest as ProtoUpsertWorkflowProviderEventTriggerRequest,
-  type UpsertWorkflowProviderScheduleRequest as ProtoUpsertWorkflowProviderScheduleRequest,
-  type WorkflowActor as ProtoWorkflowActor,
+  type WorkflowActivation as ProtoWorkflowActivation,
+  type WorkflowAgentMessage as ProtoWorkflowAgentMessage,
+  type WorkflowDefinition as ProtoWorkflowDefinition,
+  type WorkflowDefinitionSpec as ProtoWorkflowDefinitionSpec,
   type WorkflowEvent as ProtoWorkflowEvent,
+  type WorkflowEventActivation as ProtoWorkflowEventActivation,
   type WorkflowEventMatch as ProtoWorkflowEventMatch,
   type WorkflowEventTriggerInvocation as ProtoWorkflowEventTriggerInvocation,
-  WorkflowStepAgentTurnSchema,
-  WorkflowStepOutputSourceSchema,
-  WorkflowStepAppCallSchema,
-  WorkflowStepSchema,
-  WorkflowStepWhenSchema,
-  WorkflowTextSchema,
-  WorkflowValueSchema,
-  type WorkflowAgentMessage as ProtoWorkflowAgentMessage,
+  type WorkflowRun as ProtoWorkflowRun,
+  type WorkflowRunEvent as ProtoWorkflowRunEvent,
   type WorkflowRunTrigger as ProtoWorkflowRunTrigger,
+  type WorkflowScheduleActivation as ProtoWorkflowScheduleActivation,
   type WorkflowScheduleTrigger as ProtoWorkflowScheduleTrigger,
   type WorkflowSignal as ProtoWorkflowSignal,
   type WorkflowStep as ProtoWorkflowStep,
   type WorkflowStepAgentTurn as ProtoWorkflowStepAgentTurn,
-  type WorkflowStepOutputSource as ProtoWorkflowStepOutputSource,
   type WorkflowStepAppCall as ProtoWorkflowStepAppCall,
+  type WorkflowStepAttempt as ProtoWorkflowStepAttempt,
+  type WorkflowStepExecution as ProtoWorkflowStepExecution,
+  type WorkflowStepInputSource as ProtoWorkflowStepInputSource,
+  type WorkflowStepOutputSource as ProtoWorkflowStepOutputSource,
   type WorkflowStepWhen as ProtoWorkflowStepWhen,
   type WorkflowText as ProtoWorkflowText,
   type WorkflowValue as ProtoWorkflowValue,
 } from "./internal/gen/v1/workflow_pb.ts";
-import type { AgentOutput, AgentToolRef } from "./agent.ts";
-import {
-  agentOutputFromProto,
-  agentOutputToProto,
-  agentToolRefFromProto,
-  agentToolRefToProto,
-} from "./agent-conversions.ts";
-import { errorMessage, type MaybePromise, type Request } from "./api.ts";
 import { ProviderBase, type ProviderBaseOptions } from "./provider.ts";
 import {
   dateFromTimestamp,
@@ -101,16 +115,10 @@ import {
   type JsonInput,
   type JsonObjectInput,
 } from "./protocol.ts";
-import {
-  optionalObjectFromStruct,
-  optionalStruct,
-} from "./protocol-internal.ts";
+import { optionalObjectFromStruct, optionalStruct } from "./protocol-internal.ts";
 
-type WorkflowProviderServiceImpl = Partial<
-  ServiceImpl<typeof WorkflowProviderService>
->;
+type WorkflowProviderServiceImpl = Partial<ServiceImpl<typeof WorkflowProviderService>>;
 
-/** Native workflow-run status constants for authored workflow providers. */
 export const WorkflowRunStatus = {
   UNSPECIFIED: ProtoWorkflowRunStatus.UNSPECIFIED,
   PENDING: ProtoWorkflowRunStatus.PENDING,
@@ -119,26 +127,46 @@ export const WorkflowRunStatus = {
   FAILED: ProtoWorkflowRunStatus.FAILED,
   CANCELED: ProtoWorkflowRunStatus.CANCELED,
 } as const;
-export type WorkflowRunStatus =
-  (typeof WorkflowRunStatus)[keyof typeof WorkflowRunStatus];
+export type WorkflowRunStatus = (typeof WorkflowRunStatus)[keyof typeof WorkflowRunStatus];
+
+export const WorkflowStepStatus = {
+  UNSPECIFIED: ProtoWorkflowStepStatus.UNSPECIFIED,
+  PENDING: ProtoWorkflowStepStatus.PENDING,
+  RUNNING: ProtoWorkflowStepStatus.RUNNING,
+  SKIPPED: ProtoWorkflowStepStatus.SKIPPED,
+  SUCCEEDED: ProtoWorkflowStepStatus.SUCCEEDED,
+  FAILED: ProtoWorkflowStepStatus.FAILED,
+  UNKNOWN: ProtoWorkflowStepStatus.UNKNOWN,
+} as const;
+export type WorkflowStepStatus = (typeof WorkflowStepStatus)[keyof typeof WorkflowStepStatus];
 
 export interface WorkflowText {
   template?: string | undefined;
 }
 
+export interface WorkflowPathSource {
+  path?: string | undefined;
+}
+
 export interface WorkflowStepOutputSource {
   stepId?: string | undefined;
   path?: string | undefined;
 }
 
+export interface WorkflowStepInputSource {
+  stepId?: string | undefined;
+  path?: string | undefined;
+}
+
 export type WorkflowValueKind =
   | { case: "literal"; value: JsonInput }
   | { case: "object"; value: Record<string, WorkflowValue> }
   | { case: "array"; value: readonly WorkflowValue[] }
   | { case: "template"; value: WorkflowText | string }
-  | { case: "runInput"; value: string }
-  | { case: "signalPayload"; value: string }
+  | { case: "input"; value: string }
+  | { case: "signal"; value: string }
   | { case: "stepOutput"; value: WorkflowStepOutputSource }
+  | { case: "stepInput"; value: WorkflowStepInputSource }
   | { case: undefined; value?: undefined };
 
 export interface WorkflowValue {
@@ -146,9 +174,10 @@ export interface WorkflowValue {
   object?: Record<string, WorkflowValue> | undefined;
   array?: readonly WorkflowValue[] | undefined;
   template?: WorkflowText | string | undefined;
-  runInput?: string | undefined;
-  signalPayload?: string | undefined;
+  input?: string | undefined;
+  signal?: string | undefined;
   stepOutput?: WorkflowStepOutputSource | undefined;
+  stepInput?: WorkflowStepInputSource | undefined;
   kind?: WorkflowValueKind | undefined;
 }
 
@@ -174,7 +203,7 @@ export interface WorkflowStepAgentTurn {
   prompt?: WorkflowText | string | undefined;
   messages?: readonly WorkflowAgentMessage[] | undefined;
   tools?: readonly AgentToolRef[] | undefined;
-  output: AgentOutput;
+  output?: AgentOutput | undefined;
   modelOptions?: JsonObjectInput | undefined;
 }
 
@@ -192,18 +221,6 @@ export type WorkflowStepActionKind =
   | { case: "agent"; value: WorkflowStepAgentTurn }
   | { case: undefined; value?: undefined };
 
-function workflowStepAppAction(
-  action: WorkflowStepActionKind | undefined,
-): WorkflowStepAppCall | undefined {
-  return action?.case === "app" ? action.value : undefined;
-}
-
-function workflowStepAgentAction(
-  action: WorkflowStepActionKind | undefined,
-): WorkflowStepAgentTurn | undefined {
-  return action?.case === "agent" ? action.value : undefined;
-}
-
 export interface WorkflowStep {
   id?: string | undefined;
   inputs?: Record<string, WorkflowValue> | undefined;
@@ -215,13 +232,6 @@ export interface WorkflowStep {
   action?: WorkflowStepActionKind | undefined;
 }
 
-export interface WorkflowActor {
-  subjectId?: string | undefined;
-  subjectKind?: string | undefined;
-  displayName?: string | undefined;
-  authSource?: string | undefined;
-}
-
 export interface WorkflowEvent {
   id?: string | undefined;
   source?: string | undefined;
@@ -240,24 +250,68 @@ export interface WorkflowEventMatch {
   subject?: string | undefined;
 }
 
+export interface WorkflowScheduleActivation {
+  cron?: string | undefined;
+  timezone?: string | undefined;
+}
+
+export interface WorkflowEventActivation {
+  match?: WorkflowEventMatch | undefined;
+}
+
+export type WorkflowActivationTriggerKind =
+  | { case: "schedule"; value: WorkflowScheduleActivation }
+  | { case: "event"; value: WorkflowEventActivation }
+  | { case: undefined; value?: undefined };
+
+export interface WorkflowActivation {
+  id?: string | undefined;
+  input?: WorkflowValue | undefined;
+  paused?: boolean | undefined;
+  schedule?: WorkflowScheduleActivation | undefined;
+  event?: WorkflowEventActivation | undefined;
+  trigger?: WorkflowActivationTriggerKind | undefined;
+}
+
+export interface WorkflowDefinitionSpec {
+  id?: string | undefined;
+  target?: BoundWorkflowTarget | undefined;
+  activations?: readonly WorkflowActivation[] | undefined;
+  paused?: boolean | undefined;
+  runAs?: SubjectInput | undefined;
+}
+
+export interface WorkflowDefinition {
+  id?: string | undefined;
+  generation?: bigint | number | undefined;
+  target?: BoundWorkflowTarget | undefined;
+  activations?: readonly WorkflowActivation[] | undefined;
+  paused?: boolean | undefined;
+  createdBySubjectId?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+  providerName?: string | undefined;
+  runAs?: Subject | undefined;
+}
+
 export interface WorkflowSignal {
   id?: string | undefined;
   name?: string | undefined;
   payload?: JsonObjectInput | undefined;
   metadata?: JsonObjectInput | undefined;
-  createdBy?: WorkflowActor | undefined;
+  createdBySubjectId?: string | undefined;
   createdAt?: Date | undefined;
   idempotencyKey?: string | undefined;
   sequence?: bigint | number | undefined;
 }
 
 export interface WorkflowScheduleTrigger {
-  scheduleId?: string | undefined;
+  activationId?: string | undefined;
   scheduledFor?: Date | undefined;
 }
 
 export interface WorkflowEventTriggerInvocation {
-  triggerId?: string | undefined;
+  activationId?: string | undefined;
   event?: WorkflowEvent | undefined;
 }
 
@@ -274,374 +328,248 @@ export interface WorkflowRunTrigger {
   kind?: WorkflowRunTriggerKind | undefined;
 }
 
-export interface BoundWorkflowRun {
+export interface WorkflowStepAttempt {
   id?: string | undefined;
-  status?: WorkflowRunStatus | undefined;
-  target?: BoundWorkflowTarget | undefined;
-  trigger?: WorkflowRunTrigger | undefined;
-  createdAt?: Date | undefined;
+  status?: WorkflowStepStatus | undefined;
+  idempotencyKey?: string | undefined;
+  input?: JsonInput | undefined;
+  output?: JsonInput | undefined;
+  statusMessage?: string | undefined;
   startedAt?: Date | undefined;
   completedAt?: Date | undefined;
-  statusMessage?: string | undefined;
-  resultBody?: string | undefined;
-  createdBy?: WorkflowActor | undefined;
-  workflowKey?: string | undefined;
-  providerName?: string | undefined;
-  definitionId?: string | undefined;
 }
 
-export interface BoundWorkflowSchedule {
-  id?: string | undefined;
-  cron?: string | undefined;
-  timezone?: string | undefined;
-  target?: BoundWorkflowTarget | undefined;
-  paused?: boolean | undefined;
-  createdAt?: Date | undefined;
-  updatedAt?: Date | undefined;
-  nextRunAt?: Date | undefined;
-  createdBy?: WorkflowActor | undefined;
-  providerName?: string | undefined;
-  definitionId?: string | undefined;
+export interface WorkflowStepExecution {
+  stepId?: string | undefined;
+  status?: WorkflowStepStatus | undefined;
+  attempts?: readonly WorkflowStepAttempt[] | undefined;
+  input?: JsonInput | undefined;
+  output?: JsonInput | undefined;
+  statusMessage?: string | undefined;
+  skipReason?: string | undefined;
+  startedAt?: Date | undefined;
+  completedAt?: Date | undefined;
 }
 
-export interface BoundWorkflowEventTrigger {
+export interface WorkflowRun {
   id?: string | undefined;
-  match?: WorkflowEventMatch | undefined;
+  status?: WorkflowRunStatus | undefined;
   target?: BoundWorkflowTarget | undefined;
-  paused?: boolean | undefined;
+  trigger?: WorkflowRunTrigger | undefined;
   createdAt?: Date | undefined;
-  updatedAt?: Date | undefined;
-  createdBy?: WorkflowActor | undefined;
+  startedAt?: Date | undefined;
+  completedAt?: Date | undefined;
+  statusMessage?: string | undefined;
+  output?: JsonInput | undefined;
+  createdBySubjectId?: string | undefined;
+  workflowKey?: string | undefined;
   providerName?: string | undefined;
   definitionId?: string | undefined;
+  runAs?: Subject | undefined;
+  input?: JsonObjectInput | undefined;
+  definitionGeneration?: bigint | number | undefined;
+  currentStepId?: string | undefined;
+  steps?: readonly WorkflowStepExecution[] | undefined;
 }
 
-export interface BoundWorkflowDefinition {
+export interface WorkflowRunEvent {
   id?: string | undefined;
-  target?: BoundWorkflowTarget | undefined;
-  createdBy?: WorkflowActor | undefined;
+  runId?: string | undefined;
+  stepId?: string | undefined;
+  type?: string | undefined;
+  data?: JsonObjectInput | undefined;
   createdAt?: Date | undefined;
-  providerName?: string | undefined;
-}
-
-export interface StartWorkflowProviderRunRequest {
-  target?: BoundWorkflowTarget | undefined;
-  idempotencyKey: string;
-  createdBy?: WorkflowActor | undefined;
-  workflowKey: string;
-  definitionId?: string | undefined;
-}
-
-export interface GetWorkflowProviderRunRequest {
-  runId: string;
 }
 
-export interface ListWorkflowProviderRunsRequest {
-  pageSize?: number | undefined;
-  pageToken?: string | undefined;
-  status?: WorkflowRunStatus | undefined;
-  targetApp?: string | undefined;
+export interface ListWorkflowProviderDefinitionsResponse {
+  definitions: readonly WorkflowDefinition[];
 }
 
 export interface ListWorkflowProviderRunsResponse {
-  runs: readonly BoundWorkflowRun[];
+  runs: readonly WorkflowRun[];
   nextPageToken?: string | undefined;
 }
 
-export interface CancelWorkflowProviderRunRequest {
-  runId: string;
-  reason: string;
+export interface GetWorkflowProviderRunEventsResponse {
+  events: readonly WorkflowRunEvent[];
 }
 
-export interface SignalWorkflowProviderRunRequest {
-  runId: string;
-  signal?: WorkflowSignal | undefined;
+export interface GetWorkflowProviderRunOutputResponse {
+  output?: JsonInput | undefined;
 }
 
-export interface SignalOrStartWorkflowProviderRunRequest {
-  workflowKey: string;
-  target?: BoundWorkflowTarget | undefined;
-  idempotencyKey: string;
-  createdBy?: WorkflowActor | undefined;
-  signal?: WorkflowSignal | undefined;
-  definitionId?: string | undefined;
+export interface ApplyWorkflowProviderDefinitionRequest {
+  spec?: WorkflowDefinitionSpec | undefined;
+  idempotencyKey?: string | undefined;
+  requestedBySubjectId?: string | undefined;
 }
 
-export interface SignalWorkflowRunResponse {
-  run?: BoundWorkflowRun | undefined;
-  signal?: WorkflowSignal | undefined;
-  startedRun: boolean;
-  workflowKey: string;
+export interface GetWorkflowProviderDefinitionRequest {
+  definitionId: string;
 }
 
-export interface CreateWorkflowProviderDefinitionRequest {
-  target?: BoundWorkflowTarget | undefined;
-  idempotencyKey: string;
-  createdBy?: WorkflowActor | undefined;
-}
+export interface ListWorkflowProviderDefinitionsRequest {}
 
-export interface GetWorkflowProviderDefinitionRequest {
+export interface SetWorkflowProviderDefinitionPausedRequest {
   definitionId: string;
+  paused: boolean;
+  requestedBySubjectId?: string | undefined;
 }
 
-export interface UpdateWorkflowProviderDefinitionRequest {
+export interface SetWorkflowProviderActivationPausedRequest {
   definitionId: string;
-  target?: BoundWorkflowTarget | undefined;
-  requestedBy?: WorkflowActor | undefined;
+  activationId: string;
+  paused: boolean;
+  requestedBySubjectId?: string | undefined;
 }
 
 export interface DeleteWorkflowProviderDefinitionRequest {
   definitionId: string;
 }
 
-export interface UpsertWorkflowProviderScheduleRequest {
-  scheduleId: string;
-  cron: string;
-  timezone: string;
-  target?: BoundWorkflowTarget | undefined;
-  paused: boolean;
-  requestedBy?: WorkflowActor | undefined;
-  idempotencyKey?: string | undefined;
+export interface StartWorkflowProviderRunRequest {
   definitionId?: string | undefined;
-}
-
-export interface GetWorkflowProviderScheduleRequest {
-  scheduleId: string;
-}
-
-export interface ListWorkflowProviderSchedulesRequest {}
-
-export interface DeleteWorkflowProviderScheduleRequest {
-  scheduleId: string;
-}
-
-export interface PauseWorkflowProviderScheduleRequest {
-  scheduleId: string;
-}
-
-export interface ResumeWorkflowProviderScheduleRequest {
-  scheduleId: string;
-}
-
-export interface UpsertWorkflowProviderEventTriggerRequest {
-  triggerId: string;
-  match?: WorkflowEventMatch | undefined;
-  target?: BoundWorkflowTarget | undefined;
-  paused: boolean;
-  requestedBy?: WorkflowActor | undefined;
+  expectedDefinitionGeneration?: bigint | number | undefined;
+  input?: JsonObjectInput | undefined;
   idempotencyKey?: string | undefined;
-  definitionId?: string | undefined;
-}
-
-export interface GetWorkflowProviderEventTriggerRequest {
-  triggerId: string;
-}
-
-export interface ListWorkflowProviderEventTriggersRequest {}
-
-export interface DeleteWorkflowProviderEventTriggerRequest {
-  triggerId: string;
+  createdBySubjectId?: string | undefined;
+  runAs?: SubjectInput | undefined;
+  workflowKey?: string | undefined;
 }
 
-export interface PauseWorkflowProviderEventTriggerRequest {
-  triggerId: string;
+export interface GetWorkflowProviderRunRequest {
+  runId: string;
 }
 
-export interface ResumeWorkflowProviderEventTriggerRequest {
-  triggerId: string;
+export interface ListWorkflowProviderRunsRequest {
+  pageSize?: number | undefined;
+  pageToken?: string | undefined;
+  status?: WorkflowRunStatus | undefined;
+  targetApp?: string | undefined;
 }
 
-export interface PublishWorkflowProviderEventRequest {
-  appName: string;
-  event?: WorkflowEvent | undefined;
-  publishedBy?: WorkflowActor | undefined;
+export interface GetWorkflowProviderRunEventsRequest {
+  runId: string;
 }
 
-export interface WorkflowSchedule {
-  providerName?: string | undefined;
-  schedule?: BoundWorkflowSchedule | undefined;
+export interface GetWorkflowProviderRunOutputRequest {
+  runId: string;
 }
 
-export interface WorkflowEventTrigger {
-  providerName?: string | undefined;
-  trigger?: BoundWorkflowEventTrigger | undefined;
+export interface CancelWorkflowProviderRunRequest {
+  runId: string;
+  reason: string;
 }
 
-export interface WorkflowDefinition {
-  providerName?: string | undefined;
-  definition?: BoundWorkflowDefinition | undefined;
+export interface SignalWorkflowProviderRunRequest {
+  runId: string;
+  signal?: WorkflowSignal | undefined;
 }
 
-export interface WorkflowRun {
-  providerName?: string | undefined;
-  run?: BoundWorkflowRun | undefined;
+export interface SignalOrStartWorkflowProviderRunRequest {
+  workflowKey: string;
+  definitionId?: string | undefined;
+  expectedDefinitionGeneration?: bigint | number | undefined;
+  input?: JsonObjectInput | undefined;
+  idempotencyKey?: string | undefined;
+  createdBySubjectId?: string | undefined;
+  runAs?: SubjectInput | undefined;
+  signal?: WorkflowSignal | undefined;
 }
 
-export interface WorkflowRunSignal {
-  providerName?: string | undefined;
-  run?: BoundWorkflowRun | undefined;
+export interface SignalWorkflowRunResponse {
+  run?: WorkflowRun | undefined;
   signal?: WorkflowSignal | undefined;
   startedRun?: boolean | undefined;
   workflowKey?: string | undefined;
 }
 
-/** Creates workflow actor metadata from native input. */
-export function workflowActor(input: WorkflowActor = {}): WorkflowActor {
-  return {
-    subjectId: input.subjectId ?? "",
-    subjectKind: input.subjectKind ?? "",
-    displayName: input.displayName ?? "",
-    authSource: input.authSource ?? "",
-  };
-}
-
-/** Returns native input copied from workflow actor metadata. */
-export function workflowActorInputFromActor(input?: WorkflowActor): WorkflowActor | undefined {
-  return input === undefined ? undefined : { ...input };
-}
-
-/** Creates workflow event-match fields from native input. */
-export function workflowEventMatch(
-  input: WorkflowEventMatch = {},
-): WorkflowEventMatch {
-  return {
-    type: input.type ?? "",
-    source: input.source ?? "",
-    subject: input.subject ?? "",
-  };
-}
-
-/** Returns native input copied from workflow event-match fields. */
-export function workflowEventMatchInputFromMatch(
-  input?: WorkflowEventMatch,
-): WorkflowEventMatch | undefined {
-  return input === undefined ? undefined : { ...input };
+export interface DeliverWorkflowProviderEventRequest {
+  appName?: string | undefined;
+  event?: WorkflowEvent | undefined;
+  deliveredBySubjectId?: string | undefined;
 }
 
-/** Creates a bound workflow target from native input. */
 export function workflowText(input: WorkflowText | string = {}): WorkflowText {
-  if (typeof input === "string") {
-    return { template: input };
-  }
-  return { template: input.template ?? "" };
+  return typeof input === "string" ? { template: input } : { template: input.template ?? "" };
 }
 
-/** Returns native input copied from workflow text. */
-export function workflowTextInputFromText(
-  input?: WorkflowText,
-): WorkflowText | undefined {
+export function workflowTextInputFromText(input?: WorkflowText): WorkflowText | undefined {
   return input === undefined ? undefined : { template: input.template };
 }
 
-/** Creates a workflow step-output source from native input. */
-export function workflowStepOutputSource(
-  input: WorkflowStepOutputSource = {},
-): WorkflowStepOutputSource {
-  return {
-    stepId: input.stepId ?? "",
-    path: input.path ?? "",
-  };
+export function workflowPathSource(input: WorkflowPathSource | string = {}): WorkflowPathSource {
+  return typeof input === "string" ? { path: input } : { path: input.path ?? "" };
 }
 
-/** Returns native input copied from a workflow step-output source. */
-export function workflowStepOutputSourceInputFromSource(
-  input?: WorkflowStepOutputSource,
-): WorkflowStepOutputSource | undefined {
-  return input === undefined ? undefined : { ...input };
+export function workflowStepOutputSource(input: WorkflowStepOutputSource = {}): WorkflowStepOutputSource {
+  return { stepId: input.stepId ?? "", path: input.path ?? "" };
+}
+
+export function workflowStepInputSource(input: WorkflowStepInputSource = {}): WorkflowStepInputSource {
+  return { stepId: input.stepId ?? "", path: input.path ?? "" };
 }
 
-/** Creates a workflow value expression from native input. */
 export function workflowValue(input: WorkflowValue = {}): WorkflowValue {
-  if (input.kind !== undefined) {
-    return { kind: cloneWorkflowValueKind(input.kind) };
-  }
+  if (input.kind !== undefined) return { kind: cloneWorkflowValueKind(input.kind) };
   const selected = [
     Object.prototype.hasOwnProperty.call(input, "literal") ? "literal" : undefined,
     input.object === undefined ? undefined : "object",
     input.array === undefined ? undefined : "array",
     input.template === undefined ? undefined : "template",
-    input.runInput === undefined ? undefined : "runInput",
-    input.signalPayload === undefined ? undefined : "signalPayload",
+    input.input === undefined ? undefined : "input",
+    input.signal === undefined ? undefined : "signal",
     input.stepOutput === undefined ? undefined : "stepOutput",
+    input.stepInput === undefined ? undefined : "stepInput",
   ].filter((value): value is string => value !== undefined);
-  if (selected.length === 0) {
-    return { kind: { case: undefined } };
-  }
-  if (selected.length > 1) {
-    throw new Error("workflow value must set exactly one value kind");
-  }
+  if (selected.length === 0) return { kind: { case: undefined } };
+  if (selected.length > 1) throw new Error("workflow value must set exactly one value kind");
   switch (selected[0]) {
     case "literal":
       return { kind: { case: "literal", value: input.literal ?? null } };
     case "object":
-      return {
-        kind: {
-          case: "object",
-          value: Object.fromEntries(
-            Object.entries(input.object ?? {}).map(([key, value]) => [
-              key,
-              workflowValue(value),
-            ]),
-          ),
-        },
-      };
+      return { kind: { case: "object", value: mapValues(input.object ?? {}, workflowValue) } };
     case "array":
       return { kind: { case: "array", value: (input.array ?? []).map(workflowValue) } };
     case "template":
       return { kind: { case: "template", value: workflowText(input.template ?? {}) } };
-    case "runInput":
-      return { kind: { case: "runInput", value: input.runInput ?? "" } };
-    case "signalPayload":
-      return { kind: { case: "signalPayload", value: input.signalPayload ?? "" } };
+    case "input":
+      return { kind: { case: "input", value: input.input ?? "" } };
+    case "signal":
+      return { kind: { case: "signal", value: input.signal ?? "" } };
+    case "stepOutput":
+      return { kind: { case: "stepOutput", value: workflowStepOutputSource(input.stepOutput) } };
     default:
-      return {
-        kind: {
-          case: "stepOutput",
-          value: workflowStepOutputSource(input.stepOutput),
-        },
-      };
+      return { kind: { case: "stepInput", value: workflowStepInputSource(input.stepInput) } };
   }
 }
 
-/** Returns native input copied from a workflow value expression. */
-export function workflowValueInputFromValue(
-  input?: WorkflowValue,
-): WorkflowValue | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowValueInputFromValue(input?: WorkflowValue): WorkflowValue | undefined {
+  if (input === undefined) return undefined;
   const kind = input.kind;
   switch (kind?.case) {
     case "literal":
       return { literal: jsonClone(kind.value) };
     case "object":
-      return {
-        object: Object.fromEntries(
-          Object.entries(kind.value).map(([key, value]) => [
-            key,
-            workflowValueInputFromValue(value)!,
-          ]),
-        ),
-      };
+      return { object: mapValues(kind.value, (value) => workflowValueInputFromValue(value)!) };
     case "array":
       return { array: kind.value.map((value) => workflowValueInputFromValue(value)!) };
     case "template":
       return { template: workflowTextInputFromText(workflowText(kind.value)) };
-    case "runInput":
-      return { runInput: kind.value };
-    case "signalPayload":
-      return { signalPayload: kind.value };
+    case "input":
+      return { input: kind.value };
+    case "signal":
+      return { signal: kind.value };
     case "stepOutput":
-      return { stepOutput: workflowStepOutputSourceInputFromSource(kind.value) };
+      return { stepOutput: workflowStepOutputSource(kind.value) };
+    case "stepInput":
+      return { stepInput: workflowStepInputSource(kind.value) };
     default:
       return {};
   }
 }
 
-/** Creates a workflow app step call from native input. */
-export function workflowStepAppCall(
-  input: WorkflowStepAppCall = {},
-): WorkflowStepAppCall {
+export function workflowStepAppCall(input: WorkflowStepAppCall = {}): WorkflowStepAppCall {
   return {
     name: input.name ?? "",
     operation: input.operation ?? "",
@@ -652,52 +580,15 @@ export function workflowStepAppCall(
   };
 }
 
-/** Returns native input copied from a workflow app step call. */
-export function workflowStepAppCallInputFromCall(
-  input?: WorkflowStepAppCall,
-): WorkflowStepAppCall | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    name: input.name,
-    operation: input.operation,
-    input: workflowValueInputFromValue(input.input),
-    connection: input.connection,
-    instance: input.instance,
-    credentialMode: input.credentialMode,
-  };
-}
-
-/** Creates a workflow agent message from native input. */
-export function workflowAgentMessage(
-  input: WorkflowAgentMessage = {},
-): WorkflowAgentMessage {
+export function workflowAgentMessage(input: WorkflowAgentMessage = {}): WorkflowAgentMessage {
   return {
     role: input.role ?? "",
     text: input.text === undefined ? undefined : workflowText(input.text),
-    metadata: input.metadata === undefined ? undefined : structFromObject(input.metadata),
+    metadata: input.metadata === undefined ? undefined : jsonObjectClone(input.metadata),
   };
 }
 
-/** Returns native input copied from a workflow agent message. */
-export function workflowAgentMessageInputFromMessage(
-  input?: WorkflowAgentMessage,
-): WorkflowAgentMessage | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    role: input.role,
-    text: workflowTextInputFromText(input.text as WorkflowText | undefined),
-    metadata: input.metadata === undefined ? undefined : jsonObjectClone(input.metadata),
-  };
-}
-
-/** Creates a workflow agent step turn from native input. */
-export function workflowStepAgentTurn(
-  input: WorkflowStepAgentTurn,
-): WorkflowStepAgentTurn {
+export function workflowStepAgentTurn(input: WorkflowStepAgentTurn): WorkflowStepAgentTurn {
   return {
     provider: input.provider ?? "",
     model: input.model ?? "",
@@ -706,30 +597,10 @@ export function workflowStepAgentTurn(
     messages: input.messages?.map(workflowAgentMessage) ?? [],
     tools: [...(input.tools ?? [])],
     output: input.output,
-    modelOptions: input.modelOptions === undefined ? undefined : structFromObject(input.modelOptions),
-  };
-}
-
-/** Returns native input copied from a workflow agent step turn. */
-export function workflowStepAgentTurnInputFromTurn(
-  input?: WorkflowStepAgentTurn,
-): WorkflowStepAgentTurn | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    provider: input.provider,
-    model: input.model,
-    sessionKey: input.sessionKey,
-    prompt: workflowTextInputFromText(input.prompt as WorkflowText | undefined),
-    messages: input.messages?.map((message) => workflowAgentMessageInputFromMessage(message)!) ?? [],
-    tools: [...(input.tools ?? [])],
-    output: workflowAgentOutputInputFromOutput(input.output),
     modelOptions: input.modelOptions === undefined ? undefined : jsonObjectClone(input.modelOptions),
   };
 }
 
-/** Creates a condition for running one workflow step. */
 export function workflowStepWhen(input: WorkflowStepWhen = {}): WorkflowStepWhen {
   const out: WorkflowStepWhen = {
     value: input.value === undefined ? undefined : workflowValue(input.value),
@@ -740,263 +611,115 @@ export function workflowStepWhen(input: WorkflowStepWhen = {}): WorkflowStepWhen
   return out;
 }
 
-/** Returns native input copied from a workflow step condition. */
-export function workflowStepWhenInputFromWhen(
-  input?: WorkflowStepWhen,
-): WorkflowStepWhen | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const out: WorkflowStepWhen = {
-    value: workflowValueInputFromValue(input.value),
-  };
-  if (Object.prototype.hasOwnProperty.call(input, "equals")) {
-    out.equals = input.equals === undefined ? null : jsonClone(input.equals);
-  }
-  return out;
-}
-
-/** Creates one bound workflow step from native input. */
 export function workflowStep(input: WorkflowStep = {}): WorkflowStep {
-  const app = input.app ?? workflowStepAppAction(input.action);
-  const agent = input.agent ?? workflowStepAgentAction(input.action);
-  if (app !== undefined && agent !== undefined) {
-    throw new Error("workflow step must set either app or agent");
-  }
-  const action: WorkflowStepActionKind = app !== undefined
-    ? { case: "app" as const, value: workflowStepAppCall(app) }
-    : agent !== undefined
-      ? { case: "agent" as const, value: workflowStepAgentTurn(agent) }
-      : { case: undefined };
-  return {
+  const app = input.app ?? (input.action?.case === "app" ? input.action.value : undefined);
+  const agent = input.agent ?? (input.action?.case === "agent" ? input.action.value : undefined);
+  const out: WorkflowStep = {
     id: input.id ?? "",
-    inputs: Object.fromEntries(
-      Object.entries(input.inputs ?? {}).map(([key, value]) => [
-        key,
-        workflowValue(value),
-      ]),
-    ),
-    app: workflowStepAppAction(action),
-    agent: workflowStepAgentAction(action),
-    action,
+    inputs: input.inputs === undefined ? undefined : mapValues(input.inputs, workflowValue),
+    app: app === undefined ? undefined : workflowStepAppCall(app),
+    agent: agent === undefined ? undefined : workflowStepAgentTurn(agent),
     when: input.when === undefined ? undefined : workflowStepWhen(input.when),
     timeoutSeconds: input.timeoutSeconds ?? 0,
-    metadata: input.metadata === undefined ? undefined : structFromObject(input.metadata),
-  };
-}
-
-/** Returns native input copied from one bound workflow step. */
-export function workflowStepInputFromStep(
-  input?: WorkflowStep,
-): WorkflowStep | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const action = input.action;
-  const app = input.app ?? workflowStepAppAction(action);
-  const agent = input.agent ?? workflowStepAgentAction(action);
-  return {
-    id: input.id,
-    inputs: Object.fromEntries(
-      Object.entries(input.inputs ?? {}).map(([key, value]) => [
-        key,
-        workflowValueInputFromValue(value)!,
-      ]),
-    ),
-    app: workflowStepAppCallInputFromCall(app),
-    agent: workflowStepAgentTurnInputFromTurn(agent),
-    action: action === undefined
-      ? undefined
-      : action.case === "app"
-        ? { case: "app", value: workflowStepAppCallInputFromCall(action.value)! }
-        : action.case === "agent"
-          ? { case: "agent", value: workflowStepAgentTurnInputFromTurn(action.value)! }
-          : { case: undefined },
-    when: workflowStepWhenInputFromWhen(input.when),
-    timeoutSeconds: input.timeoutSeconds,
     metadata: input.metadata === undefined ? undefined : jsonObjectClone(input.metadata),
   };
+  if (out.app !== undefined) out.action = { case: "app", value: out.app };
+  if (out.agent !== undefined) out.action = { case: "agent", value: out.agent };
+  return out;
 }
 
-/** Creates a bound workflow target from native input. */
 export function boundWorkflowTarget(input: BoundWorkflowTarget = {}): BoundWorkflowTarget {
-  return {
-    steps: (input.steps ?? []).map(workflowStep),
-  };
+  return { steps: input.steps?.map(workflowStep) ?? [] };
 }
 
-/** Returns native input copied from a bound workflow target. */
-export function boundWorkflowTargetInputFromTarget(
-  input?: BoundWorkflowTarget,
-): BoundWorkflowTarget | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    steps: input.steps?.map((step) => workflowStepInputFromStep(step)!),
-  };
+export function boundWorkflowTargetInputFromTarget(input?: BoundWorkflowTarget): BoundWorkflowTarget | undefined {
+  return input === undefined ? undefined : { steps: input.steps?.map((step) => workflowStep(step)) };
 }
 
-/** Returns a deep copy of a bound workflow target. */
 export function boundWorkflowTargetFromTarget(input: BoundWorkflowTarget): BoundWorkflowTarget {
   return boundWorkflowTarget(boundWorkflowTargetInputFromTarget(input) ?? {});
 }
 
-/** Creates a workflow event from native input. */
-export function workflowEvent(input: WorkflowEvent = {}): WorkflowEvent {
-  return {
+export function workflowScheduleActivation(input: WorkflowScheduleActivation = {}): WorkflowScheduleActivation {
+  return { cron: input.cron ?? "", timezone: input.timezone ?? "" };
+}
+
+export function workflowEventMatch(input: WorkflowEventMatch = {}): WorkflowEventMatch {
+  return { type: input.type ?? "", source: input.source ?? "", subject: input.subject ?? "" };
+}
+
+export function workflowEventActivation(input: WorkflowEventActivation = {}): WorkflowEventActivation {
+  return { match: input.match === undefined ? undefined : workflowEventMatch(input.match) };
+}
+
+export function workflowActivation(input: WorkflowActivation = {}): WorkflowActivation {
+  const schedule = input.schedule ?? (input.trigger?.case === "schedule" ? input.trigger.value : undefined);
+  const event = input.event ?? (input.trigger?.case === "event" ? input.trigger.value : undefined);
+  const out: WorkflowActivation = {
     id: input.id ?? "",
-    source: input.source ?? "",
-    specVersion: input.specVersion ?? "",
-    type: input.type ?? "",
-    subject: input.subject ?? "",
-    time: input.time,
-    datacontenttype: input.datacontenttype ?? "",
-    data: input.data === undefined ? undefined : structFromObject(input.data),
-    extensions: valueMapInput(input.extensions),
+    input: input.input === undefined ? undefined : workflowValue(input.input),
+    paused: input.paused ?? false,
+    schedule: schedule === undefined ? undefined : workflowScheduleActivation(schedule),
+    event: event === undefined ? undefined : workflowEventActivation(event),
   };
+  if (out.schedule !== undefined) out.trigger = { case: "schedule", value: out.schedule };
+  if (out.event !== undefined) out.trigger = { case: "event", value: out.event };
+  return out;
 }
 
-/** Returns native input copied from a workflow event. */
-export function workflowEventInputFromEvent(input?: WorkflowEvent): WorkflowEvent | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowDefinitionSpec(input: WorkflowDefinitionSpec = {}): WorkflowDefinitionSpec {
   return {
-    id: input.id,
-    source: input.source,
-    specVersion: input.specVersion,
-    type: input.type,
-    subject: input.subject,
-    time: input.time,
-    datacontenttype: input.datacontenttype,
-    data: input.data === undefined ? undefined : jsonObjectClone(input.data),
-    extensions: input.extensions === undefined ? undefined : { ...input.extensions },
+    id: input.id ?? "",
+    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
+    activations: input.activations?.map(workflowActivation) ?? [],
+    paused: input.paused ?? false,
+    runAs: input.runAs,
   };
 }
 
-/** Returns a deep copy of a workflow event. */
-export function workflowEventFromEvent(input: WorkflowEvent): WorkflowEvent {
-  return workflowEvent(workflowEventInputFromEvent(input) ?? {});
-}
-
-/** Creates a workflow signal from native input. */
-export function workflowSignal(input: WorkflowSignal = {}): WorkflowSignal {
+export function workflowDefinition(input: WorkflowDefinition = {}): WorkflowDefinition {
   return {
     id: input.id ?? "",
-    name: input.name ?? "",
-    payload: input.payload === undefined ? undefined : structFromObject(input.payload),
-    metadata: input.metadata === undefined ? undefined : structFromObject(input.metadata),
-    createdBy: input.createdBy === undefined ? undefined : workflowActor(input.createdBy),
+    generation: BigInt(input.generation ?? 0),
+    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
+    activations: input.activations?.map(workflowActivation) ?? [],
+    paused: input.paused ?? false,
+    createdBySubjectId: input.createdBySubjectId ?? "",
     createdAt: input.createdAt,
-    idempotencyKey: input.idempotencyKey ?? "",
-    sequence: input.sequence === undefined ? 0n : BigInt(input.sequence),
+    updatedAt: input.updatedAt,
+    providerName: input.providerName ?? "",
+    runAs: input.runAs,
   };
 }
 
-/** Returns native input copied from a workflow signal. */
-export function workflowSignalInputFromSignal(input?: WorkflowSignal): WorkflowSignal | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowSignal(input: WorkflowSignal = {}): WorkflowSignal {
   return {
-    id: input.id,
-    name: input.name,
+    id: input.id ?? "",
+    name: input.name ?? "",
     payload: input.payload === undefined ? undefined : jsonObjectClone(input.payload),
     metadata: input.metadata === undefined ? undefined : jsonObjectClone(input.metadata),
-    createdBy: workflowActorInputFromActor(input.createdBy),
+    createdBySubjectId: input.createdBySubjectId ?? "",
     createdAt: input.createdAt,
-    idempotencyKey: input.idempotencyKey,
-    sequence: input.sequence,
-  };
-}
-
-/** Returns a deep copy of a workflow signal. */
-export function workflowSignalFromSignal(input: WorkflowSignal): WorkflowSignal {
-  return workflowSignal(workflowSignalInputFromSignal(input) ?? {});
-}
-
-/** Creates a workflow schedule trigger from native input. */
-export function workflowScheduleTrigger(
-  input: WorkflowScheduleTrigger = {},
-): WorkflowScheduleTrigger {
-  return {
-    scheduleId: input.scheduleId ?? "",
-    scheduledFor: input.scheduledFor,
+    idempotencyKey: input.idempotencyKey ?? "",
+    sequence: BigInt(input.sequence ?? 0),
   };
 }
 
-/** Creates a workflow event-trigger invocation from native input. */
-export function workflowEventTriggerInvocation(
-  input: WorkflowEventTriggerInvocation = {},
-): WorkflowEventTriggerInvocation {
+export function workflowEvent(input: WorkflowEvent = {}): WorkflowEvent {
   return {
-    triggerId: input.triggerId ?? "",
-    event: input.event === undefined ? undefined : workflowEvent(input.event),
+    id: input.id ?? "",
+    source: input.source ?? "",
+    specVersion: input.specVersion ?? "",
+    type: input.type ?? "",
+    subject: input.subject ?? "",
+    time: input.time,
+    datacontenttype: input.datacontenttype ?? "",
+    data: input.data === undefined ? undefined : jsonObjectClone(input.data),
+    extensions: input.extensions === undefined ? undefined : mapValues(input.extensions, jsonClone),
   };
 }
 
-/** Creates a workflow run trigger from native input. */
-export function workflowRunTrigger(
-  input: WorkflowRunTrigger = {},
-): WorkflowRunTrigger {
-  if ("kind" in input && input.kind !== undefined) {
-    return workflowRunTriggerFromTrigger({ kind: input.kind });
-  }
-  const triggerInput = input as WorkflowRunTrigger;
-  const selected = [
-    triggerInput.manual === true ? "manual" : undefined,
-    triggerInput.schedule === undefined ? undefined : "schedule",
-    triggerInput.event === undefined ? undefined : "event",
-  ].filter((value): value is string => value !== undefined);
-  if (selected.length === 0) {
-    return { kind: { case: undefined } };
-  }
-  if (selected.length > 1) {
-    throw new Error("workflow run trigger must set exactly one trigger kind");
-  }
-  switch (selected[0]) {
-    case "manual":
-      return { kind: { case: "manual", value: {} } };
-    case "schedule":
-      return { kind: { case: "schedule", value: workflowScheduleTrigger(triggerInput.schedule!) } };
-    default:
-      return { kind: { case: "event", value: workflowEventTriggerInvocation(triggerInput.event!) } };
-  }
-}
-
-/** Returns native input copied from a workflow run trigger. */
-export function workflowRunTriggerInputFromTrigger(
-  input?: WorkflowRunTrigger,
-): WorkflowRunTrigger | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const kind = input.kind;
-  switch (kind?.case) {
-    case "manual":
-      return { manual: true };
-    case "schedule":
-      return { schedule: { ...kind.value } };
-    case "event":
-      return {
-        event: {
-          triggerId: kind.value.triggerId,
-          event: workflowEventInputFromEvent(kind.value.event),
-        },
-      };
-    default:
-      return {};
-  }
-}
-
-/** Returns a deep copy of a workflow run trigger. */
-export function workflowRunTriggerFromTrigger(input: WorkflowRunTrigger): WorkflowRunTrigger {
-  return workflowRunTrigger(workflowRunTriggerInputFromTrigger(input) ?? {});
-}
-
-/** Creates a workflow-provider run from native input. */
-export function boundWorkflowRun(input: BoundWorkflowRun = {}): BoundWorkflowRun {
+export function workflowRun(input: WorkflowRun = {}): WorkflowRun {
   return {
     id: input.id ?? "",
     status: input.status ?? WorkflowRunStatus.UNSPECIFIED,
@@ -1006,400 +729,149 @@ export function boundWorkflowRun(input: BoundWorkflowRun = {}): BoundWorkflowRun
     startedAt: input.startedAt,
     completedAt: input.completedAt,
     statusMessage: input.statusMessage ?? "",
-    resultBody: input.resultBody ?? "",
-    createdBy: input.createdBy === undefined ? undefined : workflowActor(input.createdBy),
+    output: input.output === undefined ? undefined : jsonClone(input.output),
+    createdBySubjectId: input.createdBySubjectId ?? "",
     workflowKey: input.workflowKey ?? "",
     providerName: input.providerName ?? "",
     definitionId: input.definitionId ?? "",
+    runAs: input.runAs,
+    input: input.input === undefined ? undefined : jsonObjectClone(input.input),
+    definitionGeneration: BigInt(input.definitionGeneration ?? 0),
+    currentStepId: input.currentStepId ?? "",
+    steps: input.steps?.map(workflowStepExecution) ?? [],
   };
 }
 
-/** Returns native input copied from a workflow-provider run. */
-export function boundWorkflowRunInputFromRun(input?: BoundWorkflowRun): BoundWorkflowRun | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    ...input,
-    target: boundWorkflowTargetInputFromTarget(input.target) === undefined
-      ? undefined
-      : boundWorkflowTarget(input.target!),
-    trigger: workflowRunTriggerInputFromTrigger(input.trigger) === undefined
-      ? undefined
-      : workflowRunTrigger(input.trigger!),
-    createdBy: workflowActorInputFromActor(input.createdBy),
-  };
-}
-
-/** Returns a deep copy of a workflow-provider run. */
-export function boundWorkflowRunFromRun(input: BoundWorkflowRun): BoundWorkflowRun {
-  return boundWorkflowRun(boundWorkflowRunInputFromRun(input) ?? {});
-}
-
-/** Creates a workflow-provider definition from native input. */
-export function boundWorkflowDefinition(
-  input: BoundWorkflowDefinition = {},
-): BoundWorkflowDefinition {
-  return {
-    id: input.id ?? "",
-    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
-    createdBy: input.createdBy === undefined ? undefined : workflowActor(input.createdBy),
-    createdAt: input.createdAt,
-    providerName: input.providerName ?? "",
-  };
+export function workflowRunTrigger(input: WorkflowRunTrigger = {}): WorkflowRunTrigger {
+  if (input.kind !== undefined) return { kind: cloneWorkflowRunTriggerKind(input.kind) };
+  if (input.manual) return { kind: { case: "manual", value: {} } };
+  if (input.schedule !== undefined) return { kind: { case: "schedule", value: workflowScheduleTrigger(input.schedule) } };
+  if (input.event !== undefined) return { kind: { case: "event", value: workflowEventTriggerInvocation(input.event) } };
+  return { kind: { case: undefined } };
 }
 
-/** Returns native input copied from a workflow-provider definition. */
-export function boundWorkflowDefinitionInputFromDefinition(
-  input?: BoundWorkflowDefinition,
-): BoundWorkflowDefinition | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    ...input,
-    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
-    createdBy: workflowActorInputFromActor(input.createdBy),
-  };
+export function workflowScheduleTrigger(input: WorkflowScheduleTrigger = {}): WorkflowScheduleTrigger {
+  return { activationId: input.activationId ?? "", scheduledFor: input.scheduledFor };
 }
 
-/** Returns a deep copy of a workflow-provider definition. */
-export function boundWorkflowDefinitionFromDefinition(
-  input: BoundWorkflowDefinition,
-): BoundWorkflowDefinition {
-  return boundWorkflowDefinition(boundWorkflowDefinitionInputFromDefinition(input) ?? {});
+export function workflowEventTriggerInvocation(input: WorkflowEventTriggerInvocation = {}): WorkflowEventTriggerInvocation {
+  return { activationId: input.activationId ?? "", event: input.event === undefined ? undefined : workflowEvent(input.event) };
 }
 
-/** Creates a workflow-provider schedule from native input. */
-export function boundWorkflowSchedule(
-  input: BoundWorkflowSchedule = {},
-): BoundWorkflowSchedule {
+export function workflowStepAttempt(input: WorkflowStepAttempt = {}): WorkflowStepAttempt {
   return {
     id: input.id ?? "",
-    cron: input.cron ?? "",
-    timezone: input.timezone ?? "",
-    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
-    paused: input.paused ?? false,
-    createdAt: input.createdAt,
-    updatedAt: input.updatedAt,
-    nextRunAt: input.nextRunAt,
-    createdBy: input.createdBy === undefined ? undefined : workflowActor(input.createdBy),
-    providerName: input.providerName ?? "",
-    definitionId: input.definitionId ?? "",
+    status: input.status ?? WorkflowStepStatus.UNSPECIFIED,
+    idempotencyKey: input.idempotencyKey ?? "",
+    input: input.input === undefined ? undefined : jsonClone(input.input),
+    output: input.output === undefined ? undefined : jsonClone(input.output),
+    statusMessage: input.statusMessage ?? "",
+    startedAt: input.startedAt,
+    completedAt: input.completedAt,
   };
 }
 
-/** Returns native input copied from a workflow-provider schedule. */
-export function boundWorkflowScheduleInputFromSchedule(
-  input?: BoundWorkflowSchedule,
-): BoundWorkflowSchedule | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowStepExecution(input: WorkflowStepExecution = {}): WorkflowStepExecution {
   return {
-    ...input,
-    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
-    createdBy: workflowActorInputFromActor(input.createdBy),
+    stepId: input.stepId ?? "",
+    status: input.status ?? WorkflowStepStatus.UNSPECIFIED,
+    attempts: input.attempts?.map(workflowStepAttempt) ?? [],
+    input: input.input === undefined ? undefined : jsonClone(input.input),
+    output: input.output === undefined ? undefined : jsonClone(input.output),
+    statusMessage: input.statusMessage ?? "",
+    skipReason: input.skipReason ?? "",
+    startedAt: input.startedAt,
+    completedAt: input.completedAt,
   };
 }
 
-/** Returns a deep copy of a workflow-provider schedule. */
-export function boundWorkflowScheduleFromSchedule(
-  input: BoundWorkflowSchedule,
-): BoundWorkflowSchedule {
-  return boundWorkflowSchedule(boundWorkflowScheduleInputFromSchedule(input) ?? {});
-}
-
-/** Creates a workflow-provider event trigger from native input. */
-export function boundWorkflowEventTrigger(
-  input: BoundWorkflowEventTrigger = {},
-): BoundWorkflowEventTrigger {
+export function workflowRunEvent(input: WorkflowRunEvent = {}): WorkflowRunEvent {
   return {
     id: input.id ?? "",
-    match: input.match === undefined ? undefined : workflowEventMatch(input.match),
-    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
-    paused: input.paused ?? false,
+    runId: input.runId ?? "",
+    stepId: input.stepId ?? "",
+    type: input.type ?? "",
+    data: input.data === undefined ? undefined : jsonObjectClone(input.data),
     createdAt: input.createdAt,
-    updatedAt: input.updatedAt,
-    createdBy: input.createdBy === undefined ? undefined : workflowActor(input.createdBy),
-    providerName: input.providerName ?? "",
-    definitionId: input.definitionId ?? "",
-  };
-}
-
-/** Returns native input copied from a workflow-provider event trigger. */
-export function boundWorkflowEventTriggerInputFromTrigger(
-  input?: BoundWorkflowEventTrigger,
-): BoundWorkflowEventTrigger | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    ...input,
-    match: workflowEventMatchInputFromMatch(input.match),
-    target: input.target === undefined ? undefined : boundWorkflowTarget(input.target),
-    createdBy: workflowActorInputFromActor(input.createdBy),
   };
 }
 
-/** Returns a deep copy of a workflow-provider event trigger. */
-export function boundWorkflowEventTriggerFromTrigger(
-  input: BoundWorkflowEventTrigger,
-): BoundWorkflowEventTrigger {
-  return boundWorkflowEventTrigger(boundWorkflowEventTriggerInputFromTrigger(input) ?? {});
+export interface WorkflowProviderOptions extends ProviderBaseOptions {
+  applyDefinition: (request: ApplyWorkflowProviderDefinitionRequest) => MaybePromise<WorkflowDefinition>;
+  getDefinition: (request: GetWorkflowProviderDefinitionRequest) => MaybePromise<WorkflowDefinition>;
+  listDefinitions: (request: ListWorkflowProviderDefinitionsRequest) => MaybePromise<readonly WorkflowDefinition[] | ListWorkflowProviderDefinitionsResponse>;
+  setDefinitionPaused: (request: SetWorkflowProviderDefinitionPausedRequest) => MaybePromise<WorkflowDefinition>;
+  setActivationPaused: (request: SetWorkflowProviderActivationPausedRequest) => MaybePromise<WorkflowDefinition>;
+  deleteDefinition: (request: DeleteWorkflowProviderDefinitionRequest) => MaybePromise<void>;
+  startRun: (request: StartWorkflowProviderRunRequest) => MaybePromise<WorkflowRun>;
+  getRun: (request: GetWorkflowProviderRunRequest) => MaybePromise<WorkflowRun>;
+  listRuns: (request: ListWorkflowProviderRunsRequest) => MaybePromise<readonly WorkflowRun[] | ListWorkflowProviderRunsResponse>;
+  getRunEvents: (request: GetWorkflowProviderRunEventsRequest) => MaybePromise<readonly WorkflowRunEvent[] | GetWorkflowProviderRunEventsResponse>;
+  getRunOutput: (request: GetWorkflowProviderRunOutputRequest) => MaybePromise<JsonInput | GetWorkflowProviderRunOutputResponse>;
+  cancelRun: (request: CancelWorkflowProviderRunRequest) => MaybePromise<WorkflowRun>;
+  signalRun: (request: SignalWorkflowProviderRunRequest) => MaybePromise<SignalWorkflowRunResponse>;
+  signalOrStartRun: (request: SignalOrStartWorkflowProviderRunRequest) => MaybePromise<SignalWorkflowRunResponse>;
+  deliverEvent: (request: DeliverWorkflowProviderEventRequest) => MaybePromise<WorkflowEvent>;
 }
 
-/** Handlers and runtime metadata for a workflow provider. */
-export interface WorkflowProviderOptions extends ProviderBaseOptions {
-  createDefinition: (
-    request: CreateWorkflowProviderDefinitionRequest,
-  ) => MaybePromise<BoundWorkflowDefinition>;
-  getDefinition: (
-    request: GetWorkflowProviderDefinitionRequest,
-  ) => MaybePromise<BoundWorkflowDefinition>;
-  updateDefinition: (
-    request: UpdateWorkflowProviderDefinitionRequest,
-  ) => MaybePromise<BoundWorkflowDefinition>;
-  deleteDefinition: (
-    request: DeleteWorkflowProviderDefinitionRequest,
-  ) => MaybePromise<void>;
-  startRun: (
-    request: StartWorkflowProviderRunRequest,
-  ) => MaybePromise<BoundWorkflowRun>;
-  getRun: (
-    request: GetWorkflowProviderRunRequest,
-  ) => MaybePromise<BoundWorkflowRun>;
-  listRuns: (
-    request: ListWorkflowProviderRunsRequest,
-  ) => MaybePromise<readonly BoundWorkflowRun[] | ListWorkflowProviderRunsResponse>;
-  cancelRun: (
-    request: CancelWorkflowProviderRunRequest,
-  ) => MaybePromise<BoundWorkflowRun>;
-  signalRun: (
-    request: SignalWorkflowProviderRunRequest,
-  ) => MaybePromise<SignalWorkflowRunResponse>;
-  signalOrStartRun: (
-    request: SignalOrStartWorkflowProviderRunRequest,
-  ) => MaybePromise<SignalWorkflowRunResponse>;
-  upsertSchedule: (
-    request: UpsertWorkflowProviderScheduleRequest,
-  ) => MaybePromise<BoundWorkflowSchedule>;
-  getSchedule: (
-    request: GetWorkflowProviderScheduleRequest,
-  ) => MaybePromise<BoundWorkflowSchedule>;
-  listSchedules: (
-    request: ListWorkflowProviderSchedulesRequest,
-  ) => MaybePromise<readonly BoundWorkflowSchedule[]>;
-  deleteSchedule: (
-    request: DeleteWorkflowProviderScheduleRequest,
-  ) => MaybePromise<void>;
-  pauseSchedule: (
-    request: PauseWorkflowProviderScheduleRequest,
-  ) => MaybePromise<BoundWorkflowSchedule>;
-  resumeSchedule: (
-    request: ResumeWorkflowProviderScheduleRequest,
-  ) => MaybePromise<BoundWorkflowSchedule>;
-  upsertEventTrigger: (
-    request: UpsertWorkflowProviderEventTriggerRequest,
-  ) => MaybePromise<BoundWorkflowEventTrigger>;
-  getEventTrigger: (
-    request: GetWorkflowProviderEventTriggerRequest,
-  ) => MaybePromise<BoundWorkflowEventTrigger>;
-  listEventTriggers: (
-    request: ListWorkflowProviderEventTriggersRequest,
-  ) => MaybePromise<readonly BoundWorkflowEventTrigger[]>;
-  deleteEventTrigger: (
-    request: DeleteWorkflowProviderEventTriggerRequest,
-  ) => MaybePromise<void>;
-  pauseEventTrigger: (
-    request: PauseWorkflowProviderEventTriggerRequest,
-  ) => MaybePromise<BoundWorkflowEventTrigger>;
-  resumeEventTrigger: (
-    request: ResumeWorkflowProviderEventTriggerRequest,
-  ) => MaybePromise<BoundWorkflowEventTrigger>;
-  publishEvent: (
-    request: PublishWorkflowProviderEventRequest,
-  ) => MaybePromise<WorkflowEvent>;
-}
-
-/** Runtime provider implementation for the Gestalt workflow host contract. */
 export class WorkflowProvider extends ProviderBase {
   readonly kind = "workflow" as const;
 
-  private readonly createDefinitionHandler: WorkflowProviderOptions["createDefinition"];
-  private readonly getDefinitionHandler: WorkflowProviderOptions["getDefinition"];
-  private readonly updateDefinitionHandler: WorkflowProviderOptions["updateDefinition"];
-  private readonly deleteDefinitionHandler: WorkflowProviderOptions["deleteDefinition"];
-  private readonly startRunHandler: WorkflowProviderOptions["startRun"];
-  private readonly getRunHandler: WorkflowProviderOptions["getRun"];
-  private readonly listRunsHandler: WorkflowProviderOptions["listRuns"];
-  private readonly cancelRunHandler: WorkflowProviderOptions["cancelRun"];
-  private readonly signalRunHandler: WorkflowProviderOptions["signalRun"];
-  private readonly signalOrStartRunHandler: WorkflowProviderOptions["signalOrStartRun"];
-  private readonly upsertScheduleHandler: WorkflowProviderOptions["upsertSchedule"];
-  private readonly getScheduleHandler: WorkflowProviderOptions["getSchedule"];
-  private readonly listSchedulesHandler: WorkflowProviderOptions["listSchedules"];
-  private readonly deleteScheduleHandler: WorkflowProviderOptions["deleteSchedule"];
-  private readonly pauseScheduleHandler: WorkflowProviderOptions["pauseSchedule"];
-  private readonly resumeScheduleHandler: WorkflowProviderOptions["resumeSchedule"];
-  private readonly upsertEventTriggerHandler: WorkflowProviderOptions["upsertEventTrigger"];
-  private readonly getEventTriggerHandler: WorkflowProviderOptions["getEventTrigger"];
-  private readonly listEventTriggersHandler: WorkflowProviderOptions["listEventTriggers"];
-  private readonly deleteEventTriggerHandler: WorkflowProviderOptions["deleteEventTrigger"];
-  private readonly pauseEventTriggerHandler: WorkflowProviderOptions["pauseEventTrigger"];
-  private readonly resumeEventTriggerHandler: WorkflowProviderOptions["resumeEventTrigger"];
-  private readonly publishEventHandler: WorkflowProviderOptions["publishEvent"];
-
-  constructor(options: WorkflowProviderOptions) {
+  constructor(private readonly options: WorkflowProviderOptions) {
     super(options);
-    this.createDefinitionHandler = options.createDefinition;
-    this.getDefinitionHandler = options.getDefinition;
-    this.updateDefinitionHandler = options.updateDefinition;
-    this.deleteDefinitionHandler = options.deleteDefinition;
-    this.startRunHandler = options.startRun;
-    this.getRunHandler = options.getRun;
-    this.listRunsHandler = options.listRuns;
-    this.cancelRunHandler = options.cancelRun;
-    this.signalRunHandler = options.signalRun;
-    this.signalOrStartRunHandler = options.signalOrStartRun;
-    this.upsertScheduleHandler = options.upsertSchedule;
-    this.getScheduleHandler = options.getSchedule;
-    this.listSchedulesHandler = options.listSchedules;
-    this.deleteScheduleHandler = options.deleteSchedule;
-    this.pauseScheduleHandler = options.pauseSchedule;
-    this.resumeScheduleHandler = options.resumeSchedule;
-    this.upsertEventTriggerHandler = options.upsertEventTrigger;
-    this.getEventTriggerHandler = options.getEventTrigger;
-    this.listEventTriggersHandler = options.listEventTriggers;
-    this.deleteEventTriggerHandler = options.deleteEventTrigger;
-    this.pauseEventTriggerHandler = options.pauseEventTrigger;
-    this.resumeEventTriggerHandler = options.resumeEventTrigger;
-    this.publishEventHandler = options.publishEvent;
-  }
-
-  async createDefinition(
-    request: CreateWorkflowProviderDefinitionRequest,
-  ): Promise<BoundWorkflowDefinition> {
-    return await this.createDefinitionHandler(request);
-  }
-
-  async getDefinition(
-    request: GetWorkflowProviderDefinitionRequest,
-  ): Promise<BoundWorkflowDefinition> {
-    return await this.getDefinitionHandler(request);
-  }
-
-  async updateDefinition(
-    request: UpdateWorkflowProviderDefinitionRequest,
-  ): Promise<BoundWorkflowDefinition> {
-    return await this.updateDefinitionHandler(request);
-  }
-
-  async deleteDefinition(request: DeleteWorkflowProviderDefinitionRequest): Promise<void> {
-    await this.deleteDefinitionHandler(request);
-  }
-
-  async startRun(request: StartWorkflowProviderRunRequest): Promise<BoundWorkflowRun> {
-    return await this.startRunHandler(request);
   }
 
-  async getRun(request: GetWorkflowProviderRunRequest): Promise<BoundWorkflowRun> {
-    return await this.getRunHandler(request);
+  applyDefinition(request: ApplyWorkflowProviderDefinitionRequest): MaybePromise<WorkflowDefinition> {
+    return this.options.applyDefinition(request);
   }
-
-  async listRuns(
-    request: ListWorkflowProviderRunsRequest,
-  ): Promise<readonly BoundWorkflowRun[] | ListWorkflowProviderRunsResponse> {
-    return await this.listRunsHandler(request);
-  }
-
-  async cancelRun(request: CancelWorkflowProviderRunRequest): Promise<BoundWorkflowRun> {
-    return await this.cancelRunHandler(request);
-  }
-
-  async signalRun(request: SignalWorkflowProviderRunRequest): Promise<SignalWorkflowRunResponse> {
-    return await this.signalRunHandler(request);
-  }
-
-  async signalOrStartRun(
-    request: SignalOrStartWorkflowProviderRunRequest,
-  ): Promise<SignalWorkflowRunResponse> {
-    return await this.signalOrStartRunHandler(request);
+  getDefinition(request: GetWorkflowProviderDefinitionRequest): MaybePromise<WorkflowDefinition> {
+    return this.options.getDefinition(request);
   }
-
-  async upsertSchedule(request: UpsertWorkflowProviderScheduleRequest): Promise<BoundWorkflowSchedule> {
-    return await this.upsertScheduleHandler(request);
+  listDefinitions(request: ListWorkflowProviderDefinitionsRequest): MaybePromise<readonly WorkflowDefinition[] | ListWorkflowProviderDefinitionsResponse> {
+    return this.options.listDefinitions(request);
   }
-
-  async getSchedule(request: GetWorkflowProviderScheduleRequest): Promise<BoundWorkflowSchedule> {
-    return await this.getScheduleHandler(request);
+  setDefinitionPaused(request: SetWorkflowProviderDefinitionPausedRequest): MaybePromise<WorkflowDefinition> {
+    return this.options.setDefinitionPaused(request);
   }
-
-  async listSchedules(
-    request: ListWorkflowProviderSchedulesRequest,
-  ): Promise<readonly BoundWorkflowSchedule[]> {
-    return await this.listSchedulesHandler(request);
+  setActivationPaused(request: SetWorkflowProviderActivationPausedRequest): MaybePromise<WorkflowDefinition> {
+    return this.options.setActivationPaused(request);
   }
-
-  async deleteSchedule(request: DeleteWorkflowProviderScheduleRequest): Promise<void> {
-    await this.deleteScheduleHandler(request);
+  deleteDefinition(request: DeleteWorkflowProviderDefinitionRequest): MaybePromise<void> {
+    return this.options.deleteDefinition(request);
   }
-
-  async pauseSchedule(request: PauseWorkflowProviderScheduleRequest): Promise<BoundWorkflowSchedule> {
-    return await this.pauseScheduleHandler(request);
+  startRun(request: StartWorkflowProviderRunRequest): MaybePromise<WorkflowRun> {
+    return this.options.startRun(request);
   }
-
-  async resumeSchedule(request: ResumeWorkflowProviderScheduleRequest): Promise<BoundWorkflowSchedule> {
-    return await this.resumeScheduleHandler(request);
+  getRun(request: GetWorkflowProviderRunRequest): MaybePromise<WorkflowRun> {
+    return this.options.getRun(request);
   }
-
-  async upsertEventTrigger(
-    request: UpsertWorkflowProviderEventTriggerRequest,
-  ): Promise<BoundWorkflowEventTrigger> {
-    return await this.upsertEventTriggerHandler(request);
+  listRuns(request: ListWorkflowProviderRunsRequest): MaybePromise<readonly WorkflowRun[] | ListWorkflowProviderRunsResponse> {
+    return this.options.listRuns(request);
   }
-
-  async getEventTrigger(
-    request: GetWorkflowProviderEventTriggerRequest,
-  ): Promise<BoundWorkflowEventTrigger> {
-    return await this.getEventTriggerHandler(request);
+  getRunEvents(request: GetWorkflowProviderRunEventsRequest): MaybePromise<readonly WorkflowRunEvent[] | GetWorkflowProviderRunEventsResponse> {
+    return this.options.getRunEvents(request);
   }
-
-  async listEventTriggers(
-    request: ListWorkflowProviderEventTriggersRequest,
-  ): Promise<readonly BoundWorkflowEventTrigger[]> {
-    return await this.listEventTriggersHandler(request);
+  getRunOutput(request: GetWorkflowProviderRunOutputRequest): MaybePromise<JsonInput | GetWorkflowProviderRunOutputResponse> {
+    return this.options.getRunOutput(request);
   }
-
-  async deleteEventTrigger(request: DeleteWorkflowProviderEventTriggerRequest): Promise<void> {
-    await this.deleteEventTriggerHandler(request);
+  cancelRun(request: CancelWorkflowProviderRunRequest): MaybePromise<WorkflowRun> {
+    return this.options.cancelRun(request);
   }
-
-  async pauseEventTrigger(
-    request: PauseWorkflowProviderEventTriggerRequest,
-  ): Promise<BoundWorkflowEventTrigger> {
-    return await this.pauseEventTriggerHandler(request);
+  signalRun(request: SignalWorkflowProviderRunRequest): MaybePromise<SignalWorkflowRunResponse> {
+    return this.options.signalRun(request);
   }
-
-  async resumeEventTrigger(
-    request: ResumeWorkflowProviderEventTriggerRequest,
-  ): Promise<BoundWorkflowEventTrigger> {
-    return await this.resumeEventTriggerHandler(request);
+  signalOrStartRun(request: SignalOrStartWorkflowProviderRunRequest): MaybePromise<SignalWorkflowRunResponse> {
+    return this.options.signalOrStartRun(request);
   }
-
-  async publishEvent(request: PublishWorkflowProviderEventRequest): Promise<WorkflowEvent> {
-    return await this.publishEventHandler(request);
+  deliverEvent(request: DeliverWorkflowProviderEventRequest): MaybePromise<WorkflowEvent> {
+    return this.options.deliverEvent(request);
   }
 }
 
-/** Creates a workflow provider for export from a provider module. */
-export function defineWorkflowProvider(
-  options: WorkflowProviderOptions,
-): WorkflowProvider {
+export function defineWorkflowProvider(options: WorkflowProviderOptions): WorkflowProvider {
   return new WorkflowProvider(options);
 }
 
-/** Runtime type guard for workflow providers loaded from user modules. */
 export function isWorkflowProvider(value: unknown): value is WorkflowProvider {
   return (
     value instanceof WorkflowProvider ||
@@ -1407,449 +879,204 @@ export function isWorkflowProvider(value: unknown): value is WorkflowProvider {
       value !== null &&
       "kind" in value &&
       (value as { kind?: unknown }).kind === "workflow" &&
-      "createDefinition" in value &&
+      "applyDefinition" in value &&
       "getDefinition" in value &&
-      "updateDefinition" in value &&
+      "listDefinitions" in value &&
+      "setDefinitionPaused" in value &&
+      "setActivationPaused" in value &&
       "deleteDefinition" in value &&
       "startRun" in value &&
       "getRun" in value &&
       "listRuns" in value &&
+      "getRunEvents" in value &&
+      "getRunOutput" in value &&
       "cancelRun" in value &&
       "signalRun" in value &&
       "signalOrStartRun" in value &&
-      "upsertSchedule" in value &&
-      "getSchedule" in value &&
-      "listSchedules" in value &&
-      "deleteSchedule" in value &&
-      "pauseSchedule" in value &&
-      "resumeSchedule" in value &&
-      "upsertEventTrigger" in value &&
-      "getEventTrigger" in value &&
-      "listEventTriggers" in value &&
-      "deleteEventTrigger" in value &&
-      "pauseEventTrigger" in value &&
-      "resumeEventTrigger" in value &&
-      "publishEvent" in value)
+      "deliverEvent" in value)
   );
 }
 
-/** Builds the Connect service implementation used by the TypeScript runtime. */
-export function createWorkflowProviderService(
-  provider: WorkflowProvider,
-): WorkflowProviderServiceImpl {
+export function createWorkflowProviderService(provider: WorkflowProvider): WorkflowProviderServiceImpl {
   return {
-    async createDefinition(request) {
-      return create(
-        BoundWorkflowDefinitionSchema,
-        boundWorkflowDefinitionToProto(
-          await invokeWorkflowProvider("create definition", () =>
-            provider.createDefinition(createWorkflowProviderDefinitionRequestFromProto(request)),
-          ),
-        ),
-      );
+    async applyDefinition(request) {
+      return create(WorkflowDefinitionSchema, workflowDefinitionToProto(
+        await invokeWorkflowProvider("apply definition", () => provider.applyDefinition(applyWorkflowProviderDefinitionRequestFromProto(request))),
+      ));
     },
     async getDefinition(request) {
-      return create(
-        BoundWorkflowDefinitionSchema,
-        boundWorkflowDefinitionToProto(
-          await invokeWorkflowProvider("get definition", () =>
-            provider.getDefinition(getWorkflowProviderDefinitionRequestFromProto(request)),
-          ),
-        ),
-      );
+      return create(WorkflowDefinitionSchema, workflowDefinitionToProto(
+        await invokeWorkflowProvider("get definition", () => provider.getDefinition(getWorkflowProviderDefinitionRequestFromProto(request))),
+      ));
     },
-    async updateDefinition(request) {
-      return create(
-        BoundWorkflowDefinitionSchema,
-        boundWorkflowDefinitionToProto(
-          await invokeWorkflowProvider("update definition", () =>
-            provider.updateDefinition(updateWorkflowProviderDefinitionRequestFromProto(request)),
-          ),
-        ),
-      );
+    async listDefinitions(request) {
+      const result = listDefinitionsResult(await invokeWorkflowProvider("list definitions", () => provider.listDefinitions({})));
+      void request;
+      return create(ListWorkflowProviderDefinitionsResponseSchema, {
+        definitions: result.definitions.map(workflowDefinitionToProto),
+      });
+    },
+    async setDefinitionPaused(request) {
+      return create(WorkflowDefinitionSchema, workflowDefinitionToProto(
+        await invokeWorkflowProvider("set definition paused", () => provider.setDefinitionPaused(setWorkflowProviderDefinitionPausedRequestFromProto(request))),
+      ));
+    },
+    async setActivationPaused(request) {
+      return create(WorkflowDefinitionSchema, workflowDefinitionToProto(
+        await invokeWorkflowProvider("set activation paused", () => provider.setActivationPaused(setWorkflowProviderActivationPausedRequestFromProto(request))),
+      ));
     },
     async deleteDefinition(request) {
-      await invokeWorkflowProvider("delete definition", () =>
-        provider.deleteDefinition(deleteWorkflowProviderDefinitionRequestFromProto(request)),
-      );
+      await invokeWorkflowProvider("delete definition", () => provider.deleteDefinition(deleteWorkflowProviderDefinitionRequestFromProto(request)));
       return create(EmptySchema, {});
     },
     async startRun(request) {
-      return create(
-        BoundWorkflowRunSchema,
-        boundWorkflowRunToProto(
-          await invokeWorkflowProvider("start run", () =>
-            provider.startRun(startWorkflowProviderRunRequestFromProto(request)),
-          ),
-        ),
-      );
+      return create(WorkflowRunSchema, workflowRunToProto(
+        await invokeWorkflowProvider("start run", () => provider.startRun(startWorkflowProviderRunRequestFromProto(request))),
+      ));
     },
     async getRun(request) {
-      return create(
-        BoundWorkflowRunSchema,
-        boundWorkflowRunToProto(
-          await invokeWorkflowProvider("get run", () =>
-            provider.getRun(getWorkflowProviderRunRequestFromProto(request)),
-          ),
-        ),
-      );
+      return create(WorkflowRunSchema, workflowRunToProto(
+        await invokeWorkflowProvider("get run", () => provider.getRun(getWorkflowProviderRunRequestFromProto(request))),
+      ));
     },
     async listRuns(request) {
-      const response = await invokeWorkflowProvider("list runs", () =>
-        provider.listRuns(listWorkflowProviderRunsRequestFromProto(request)),
-      );
-      const result = listRunsResult(response);
+      const result = listRunsResult(await invokeWorkflowProvider("list runs", () => provider.listRuns(listWorkflowProviderRunsRequestFromProto(request))));
       return create(ListWorkflowProviderRunsResponseSchema, {
-        runs: result.runs.map(boundWorkflowRunToProto),
+        runs: result.runs.map(workflowRunToProto),
         nextPageToken: result.nextPageToken ?? "",
       });
     },
-    async cancelRun(request) {
-      return create(
-        BoundWorkflowRunSchema,
-        boundWorkflowRunToProto(
-          await invokeWorkflowProvider("cancel run", () =>
-            provider.cancelRun(cancelWorkflowProviderRunRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async signalRun(request) {
-      return create(
-        SignalWorkflowRunResponseSchema,
-        signalWorkflowRunResponseToProto(
-          await invokeWorkflowProvider("signal run", () =>
-            provider.signalRun(signalWorkflowProviderRunRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async signalOrStartRun(request) {
-      return create(
-        SignalWorkflowRunResponseSchema,
-        signalWorkflowRunResponseToProto(
-          await invokeWorkflowProvider("signal or start run", () =>
-            provider.signalOrStartRun(signalOrStartWorkflowProviderRunRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async upsertSchedule(request) {
-      return create(
-        BoundWorkflowScheduleSchema,
-        boundWorkflowScheduleToProto(
-          await invokeWorkflowProvider("upsert schedule", () =>
-            provider.upsertSchedule(upsertWorkflowProviderScheduleRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async getSchedule(request) {
-      return create(
-        BoundWorkflowScheduleSchema,
-        boundWorkflowScheduleToProto(
-          await invokeWorkflowProvider("get schedule", () =>
-            provider.getSchedule(getWorkflowProviderScheduleRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async listSchedules(request) {
-      return create(ListWorkflowProviderSchedulesResponseSchema, {
-        schedules: (
-          await invokeWorkflowProvider("list schedules", () =>
-            provider.listSchedules(listWorkflowProviderSchedulesRequestFromProto(request)),
-          )
-        ).map(boundWorkflowScheduleToProto),
+    async getRunEvents(request) {
+      const result = runEventsResult(await invokeWorkflowProvider("get run events", () => provider.getRunEvents(getWorkflowProviderRunEventsRequestFromProto(request))));
+      return create(GetWorkflowProviderRunEventsResponseSchema, {
+        events: result.events.map(workflowRunEventToProto),
       });
     },
-    async deleteSchedule(request) {
-      await invokeWorkflowProvider("delete schedule", () =>
-        provider.deleteSchedule(deleteWorkflowProviderScheduleRequestFromProto(request)),
-      );
-      return create(EmptySchema, {});
-    },
-    async pauseSchedule(request) {
-      return create(
-        BoundWorkflowScheduleSchema,
-        boundWorkflowScheduleToProto(
-          await invokeWorkflowProvider("pause schedule", () =>
-            provider.pauseSchedule(pauseWorkflowProviderScheduleRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async resumeSchedule(request) {
-      return create(
-        BoundWorkflowScheduleSchema,
-        boundWorkflowScheduleToProto(
-          await invokeWorkflowProvider("resume schedule", () =>
-            provider.resumeSchedule(resumeWorkflowProviderScheduleRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async upsertEventTrigger(request) {
-      return create(
-        BoundWorkflowEventTriggerSchema,
-        boundWorkflowEventTriggerToProto(
-          await invokeWorkflowProvider("upsert event trigger", () =>
-            provider.upsertEventTrigger(upsertWorkflowProviderEventTriggerRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async getEventTrigger(request) {
-      return create(
-        BoundWorkflowEventTriggerSchema,
-        boundWorkflowEventTriggerToProto(
-          await invokeWorkflowProvider("get event trigger", () =>
-            provider.getEventTrigger(getWorkflowProviderEventTriggerRequestFromProto(request)),
-          ),
-        ),
-      );
-    },
-    async listEventTriggers(request) {
-      return create(ListWorkflowProviderEventTriggersResponseSchema, {
-        triggers: (
-          await invokeWorkflowProvider("list event triggers", () =>
-            provider.listEventTriggers(listWorkflowProviderEventTriggersRequestFromProto(request)),
-          )
-        ).map(boundWorkflowEventTriggerToProto),
+    async getRunOutput(request) {
+      const result = runOutputResult(await invokeWorkflowProvider("get run output", () => provider.getRunOutput(getWorkflowProviderRunOutputRequestFromProto(request))));
+      return create(GetWorkflowProviderRunOutputResponseSchema, {
+        output: result.output === undefined ? undefined : valueFromJson(result.output),
       });
     },
-    async deleteEventTrigger(request) {
-      await invokeWorkflowProvider("delete event trigger", () =>
-        provider.deleteEventTrigger(deleteWorkflowProviderEventTriggerRequestFromProto(request)),
-      );
-      return create(EmptySchema, {});
+    async cancelRun(request) {
+      return create(WorkflowRunSchema, workflowRunToProto(
+        await invokeWorkflowProvider("cancel run", () => provider.cancelRun(cancelWorkflowProviderRunRequestFromProto(request))),
+      ));
     },
-    async pauseEventTrigger(request) {
-      return create(
-        BoundWorkflowEventTriggerSchema,
-        boundWorkflowEventTriggerToProto(
-          await invokeWorkflowProvider("pause event trigger", () =>
-            provider.pauseEventTrigger(pauseWorkflowProviderEventTriggerRequestFromProto(request)),
-          ),
-        ),
-      );
+    async signalRun(request) {
+      return create(SignalWorkflowRunResponseSchema, signalWorkflowRunResponseToProto(
+        await invokeWorkflowProvider("signal run", () => provider.signalRun(signalWorkflowProviderRunRequestFromProto(request))),
+      ));
     },
-    async resumeEventTrigger(request) {
-      return create(
-        BoundWorkflowEventTriggerSchema,
-        boundWorkflowEventTriggerToProto(
-          await invokeWorkflowProvider("resume event trigger", () =>
-            provider.resumeEventTrigger(resumeWorkflowProviderEventTriggerRequestFromProto(request)),
-          ),
-        ),
-      );
+    async signalOrStartRun(request) {
+      return create(SignalWorkflowRunResponseSchema, signalWorkflowRunResponseToProto(
+        await invokeWorkflowProvider("signal or start run", () => provider.signalOrStartRun(signalOrStartWorkflowProviderRunRequestFromProto(request))),
+      ));
     },
-    async publishEvent(request) {
-      return workflowEventToProto(
-        await invokeWorkflowProvider("publish event", () =>
-          provider.publishEvent(publishWorkflowProviderEventRequestFromProto(request)),
-        ),
-      ) ?? create(WorkflowEventSchema, {});
+    async deliverEvent(request) {
+      return workflowEventToProto(await invokeWorkflowProvider("deliver event", () => provider.deliverEvent(deliverWorkflowProviderEventRequestFromProto(request)))) ?? create(WorkflowEventSchema, {});
     },
   };
 }
 
-export function workflowActorToProto(input?: WorkflowActor | undefined): ProtoWorkflowActor | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return create(WorkflowActorSchema, {
-    subjectId: input.subjectId ?? "",
-    subjectKind: input.subjectKind ?? "",
-    displayName: input.displayName ?? "",
-    authSource: input.authSource ?? "",
-  });
+export function workflowTextToProto(input?: WorkflowText | string): ProtoWorkflowText | undefined {
+  if (input === undefined) return undefined;
+  const text = workflowText(input);
+  return create(WorkflowTextSchema, { template: text.template ?? "" });
 }
 
-export function workflowActorFromProto(input?: ProtoWorkflowActor | undefined): WorkflowActor | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    subjectId: input.subjectId,
-    subjectKind: input.subjectKind,
-    displayName: input.displayName,
-    authSource: input.authSource,
-  };
+export function workflowTextFromProto(input?: ProtoWorkflowText): WorkflowText | undefined {
+  return input === undefined ? undefined : { template: input.template };
 }
 
-export function workflowEventMatchToProto(
-  input?: WorkflowEventMatch | undefined,
-): ProtoWorkflowEventMatch | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return create(WorkflowEventMatchSchema, {
-    type: input.type ?? "",
-    source: input.source ?? "",
-    subject: input.subject ?? "",
+export function workflowPathSourceToProto(input?: WorkflowPathSource | string): { path: string } | undefined {
+  if (input === undefined) return undefined;
+  const source = workflowPathSource(input);
+  return create(WorkflowPathSourceSchema, { path: source.path ?? "" });
+}
+
+export function workflowStepOutputSourceToProto(input?: WorkflowStepOutputSource): ProtoWorkflowStepOutputSource | undefined {
+  if (input === undefined) return undefined;
+  const source = workflowStepOutputSource(input);
+  return create(WorkflowStepOutputSourceSchema, {
+    stepId: source.stepId ?? "",
+    path: source.path ?? "",
   });
 }
 
-export function workflowEventMatchFromProto(
-  input?: ProtoWorkflowEventMatch | undefined,
-): WorkflowEventMatch | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    type: input.type,
-    source: input.source,
-    subject: input.subject,
-  };
+export function workflowStepOutputSourceFromProto(input?: ProtoWorkflowStepOutputSource): WorkflowStepOutputSource | undefined {
+  return input === undefined ? undefined : { stepId: input.stepId, path: input.path };
 }
 
-export function workflowTextToProto(
-  input?: WorkflowText | string | undefined,
-): ProtoWorkflowText | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const text = workflowText(input);
-  return create(WorkflowTextSchema, { template: text.template ?? "" });
-}
-
-export function workflowTextFromProto(
-  input?: ProtoWorkflowText | undefined,
-): WorkflowText | undefined {
-  return input === undefined ? undefined : { template: input.template };
-}
-
-export function workflowStepOutputSourceToProto(
-  input?: WorkflowStepOutputSource | undefined,
-): ProtoWorkflowStepOutputSource | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return create(WorkflowStepOutputSourceSchema, {
-    stepId: input.stepId ?? "",
-    path: input.path ?? "",
+export function workflowStepInputSourceToProto(input?: WorkflowStepInputSource): ProtoWorkflowStepInputSource | undefined {
+  if (input === undefined) return undefined;
+  const source = workflowStepInputSource(input);
+  return create(WorkflowStepInputSourceSchema, {
+    stepId: source.stepId ?? "",
+    path: source.path ?? "",
   });
 }
 
-export function workflowStepOutputSourceFromProto(
-  input?: ProtoWorkflowStepOutputSource | undefined,
-): WorkflowStepOutputSource | undefined {
-  return input === undefined
-    ? undefined
-    : { stepId: input.stepId, path: input.path };
+export function workflowStepInputSourceFromProto(input?: ProtoWorkflowStepInputSource): WorkflowStepInputSource | undefined {
+  return input === undefined ? undefined : { stepId: input.stepId, path: input.path };
 }
 
-export function workflowValueToProto(
-  input?: WorkflowValue | undefined,
-): ProtoWorkflowValue | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const value = workflowValue(input);
-  const kind = value.kind;
+export function workflowValueToProto(input?: WorkflowValue): ProtoWorkflowValue | undefined {
+  if (input === undefined) return undefined;
+  const kind = workflowValue(input).kind;
   switch (kind?.case) {
     case "literal":
-      return create(WorkflowValueSchema, {
-        kind: { case: "literal", value: valueFromJson(kind.value) },
-      });
+      return create(WorkflowValueSchema, { kind: { case: "literal", value: valueFromJson(kind.value) } });
     case "object":
       return create(WorkflowValueSchema, {
-        kind: {
-          case: "object",
-          value: create(WorkflowObjectSchema, {
-            fields: Object.fromEntries(
-              Object.entries(kind.value).map(([key, nested]) => [
-                key,
-                workflowValueToProto(nested)!,
-              ]),
-            ),
-          }),
-        },
+        kind: { case: "object", value: create(WorkflowObjectSchema, { fields: mapValues(kind.value, (value) => workflowValueToProto(value)!) }) },
       });
     case "array":
       return create(WorkflowValueSchema, {
-        kind: {
-          case: "array",
-          value: create(WorkflowArraySchema, {
-            values: kind.value.map((nested) => workflowValueToProto(nested)!),
-          }),
-        },
+        kind: { case: "array", value: create(WorkflowArraySchema, { values: kind.value.map((value) => workflowValueToProto(value)!) }) },
       });
     case "template":
-      return create(WorkflowValueSchema, {
-        kind: { case: "template", value: workflowTextToProto(kind.value)! },
-      });
-    case "runInput":
-      return create(WorkflowValueSchema, {
-        kind: {
-          case: "runInput",
-          value: create(WorkflowPathSourceSchema, { path: kind.value }),
-        },
-      });
-    case "signalPayload":
-      return create(WorkflowValueSchema, {
-        kind: {
-          case: "signalPayload",
-          value: create(WorkflowPathSourceSchema, { path: kind.value }),
-        },
-      });
+      return create(WorkflowValueSchema, { kind: { case: "template", value: workflowTextToProto(kind.value)! } });
+    case "input":
+      return create(WorkflowValueSchema, { kind: { case: "input", value: workflowPathSourceToProto(kind.value)! } });
+    case "signal":
+      return create(WorkflowValueSchema, { kind: { case: "signal", value: workflowPathSourceToProto(kind.value)! } });
     case "stepOutput":
-      return create(WorkflowValueSchema, {
-        kind: { case: "stepOutput", value: workflowStepOutputSourceToProto(kind.value)! },
-      });
+      return create(WorkflowValueSchema, { kind: { case: "stepOutput", value: workflowStepOutputSourceToProto(kind.value)! } });
+    case "stepInput":
+      return create(WorkflowValueSchema, { kind: { case: "stepInput", value: workflowStepInputSourceToProto(kind.value)! } });
     default:
       return create(WorkflowValueSchema);
   }
 }
 
-export function workflowValueFromProto(
-  input?: ProtoWorkflowValue | undefined,
-): WorkflowValue | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowValueFromProto(input?: ProtoWorkflowValue): WorkflowValue | undefined {
+  if (input === undefined) return undefined;
   switch (input.kind.case) {
     case "literal":
       return { kind: { case: "literal", value: jsonFromValue(input.kind.value) as JsonInput } };
     case "object":
-      return {
-        kind: {
-          case: "object",
-          value: Object.fromEntries(
-            Object.entries(input.kind.value.fields).map(([key, nested]) => [
-              key,
-              workflowValueFromProto(nested)!,
-            ]),
-          ),
-        },
-      };
+      return { kind: { case: "object", value: mapValues(input.kind.value.fields, (value) => workflowValueFromProto(value)!) } };
     case "array":
-      return {
-        kind: {
-          case: "array",
-          value: input.kind.value.values.map((nested) => workflowValueFromProto(nested)!),
-        },
-      };
+      return { kind: { case: "array", value: input.kind.value.values.map((value) => workflowValueFromProto(value)!) } };
     case "template":
       return { kind: { case: "template", value: workflowTextFromProto(input.kind.value)! } };
-    case "runInput":
-      return { kind: { case: "runInput", value: input.kind.value.path } };
-    case "signalPayload":
-      return { kind: { case: "signalPayload", value: input.kind.value.path } };
+    case "input":
+      return { kind: { case: "input", value: input.kind.value.path } };
+    case "signal":
+      return { kind: { case: "signal", value: input.kind.value.path } };
     case "stepOutput":
       return { kind: { case: "stepOutput", value: workflowStepOutputSourceFromProto(input.kind.value)! } };
+    case "stepInput":
+      return { kind: { case: "stepInput", value: workflowStepInputSourceFromProto(input.kind.value)! } };
     default:
       return { kind: { case: undefined } };
   }
 }
 
-export function workflowStepAppCallToProto(
-  input?: WorkflowStepAppCall | undefined,
-): ProtoWorkflowStepAppCall | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowStepAppCallToProto(input?: WorkflowStepAppCall): ProtoWorkflowStepAppCall | undefined {
+  if (input === undefined) return undefined;
   return create(WorkflowStepAppCallSchema, {
     name: input.name ?? "",
     operation: input.operation ?? "",
@@ -1860,12 +1087,8 @@ export function workflowStepAppCallToProto(
   });
 }
 
-export function workflowStepAppCallFromProto(
-  input?: ProtoWorkflowStepAppCall | undefined,
-): WorkflowStepAppCall | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowStepAppCallFromProto(input?: ProtoWorkflowStepAppCall): WorkflowStepAppCall | undefined {
+  if (input === undefined) return undefined;
   return {
     name: input.name,
     operation: input.operation,
@@ -1876,9 +1099,7 @@ export function workflowStepAppCallFromProto(
   };
 }
 
-export function workflowAgentMessageToProto(
-  input: WorkflowAgentMessage,
-): ProtoWorkflowAgentMessage {
+export function workflowAgentMessageToProto(input: WorkflowAgentMessage): ProtoWorkflowAgentMessage {
   return create(WorkflowAgentMessageSchema, {
     role: input.role ?? "",
     text: workflowTextToProto(input.text),
@@ -1886,9 +1107,8 @@ export function workflowAgentMessageToProto(
   });
 }
 
-export function workflowAgentMessageFromProto(
-  input: ProtoWorkflowAgentMessage,
-): WorkflowAgentMessage {
+export function workflowAgentMessageFromProto(input?: ProtoWorkflowAgentMessage): WorkflowAgentMessage | undefined {
+  if (input === undefined) return undefined;
   return {
     role: input.role,
     text: workflowTextFromProto(input.text),
@@ -1896,12 +1116,8 @@ export function workflowAgentMessageFromProto(
   };
 }
 
-export function workflowStepAgentTurnToProto(
-  input?: WorkflowStepAgentTurn | undefined,
-): ProtoWorkflowStepAgentTurn | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowStepAgentTurnToProto(input?: WorkflowStepAgentTurn): ProtoWorkflowStepAgentTurn | undefined {
+  if (input === undefined) return undefined;
   return create(WorkflowStepAgentTurnSchema, {
     provider: input.provider ?? "",
     model: input.model ?? "",
@@ -1914,275 +1130,283 @@ export function workflowStepAgentTurnToProto(
   });
 }
 
-export function workflowStepAgentTurnFromProto(
-	input?: ProtoWorkflowStepAgentTurn | undefined,
-): WorkflowStepAgentTurn | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const output = agentOutputFromProto(input.output);
-  if (output === undefined) {
-    throw new Error("workflow agent output is required");
-  }
+export function workflowStepAgentTurnFromProto(input?: ProtoWorkflowStepAgentTurn): WorkflowStepAgentTurn | undefined {
+  if (input === undefined) return undefined;
   return {
     provider: input.provider,
     model: input.model,
     sessionKey: input.sessionKey,
     prompt: workflowTextFromProto(input.prompt),
-    messages: input.messages.map(workflowAgentMessageFromProto),
+    messages: input.messages.map((message) => workflowAgentMessageFromProto(message)!),
     tools: input.tools.map(agentToolRefFromProto),
-    output,
+    output: agentOutputFromProto(input.output),
     modelOptions: optionalObjectFromStruct(input.modelOptions),
   };
 }
 
-export function workflowStepWhenToProto(
-  input?: WorkflowStepWhen | undefined,
-): ProtoWorkflowStepWhen | undefined {
-  if (input === undefined) {
-    return undefined;
+export function workflowStepWhenToProto(input?: WorkflowStepWhen): ProtoWorkflowStepWhen | undefined {
+  if (input === undefined) return undefined;
+  const out = create(WorkflowStepWhenSchema, { value: workflowValueToProto(input.value) });
+  if (Object.prototype.hasOwnProperty.call(input, "equals")) {
+    out.equals = valueFromJson(input.equals === undefined ? null : input.equals);
   }
-  return create(WorkflowStepWhenSchema, {
-    value: workflowValueToProto(input.value),
-    equals: Object.prototype.hasOwnProperty.call(input, "equals")
-      ? valueFromJson(input.equals ?? null)
-      : undefined,
-  });
+  return out;
 }
 
-export function workflowStepWhenFromProto(
-  input?: ProtoWorkflowStepWhen | undefined,
-): WorkflowStepWhen | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const out: WorkflowStepWhen = {
-    value: workflowValueFromProto(input.value),
-  };
-  if (input.equals !== undefined) {
-    out.equals = jsonFromValue(input.equals) as JsonInput;
-  }
+export function workflowStepWhenFromProto(input?: ProtoWorkflowStepWhen): WorkflowStepWhen | undefined {
+  if (input === undefined) return undefined;
+  const out: WorkflowStepWhen = { value: workflowValueFromProto(input.value) };
+  if (input.equals !== undefined) out.equals = jsonFromValue(input.equals) as JsonInput;
   return out;
 }
 
 export function workflowStepToProto(input: WorkflowStep): ProtoWorkflowStep {
   const step = workflowStep(input);
-  const action = step.action;
+  const app = step.app ?? (step.action?.case === "app" ? step.action.value : undefined);
+  const agent = step.agent ?? (step.action?.case === "agent" ? step.action.value : undefined);
   return create(WorkflowStepSchema, {
     id: step.id ?? "",
-    inputs: Object.fromEntries(
-      Object.entries(step.inputs ?? {}).map(([key, value]) => [
-        key,
-        workflowValueToProto(value)!,
-      ]),
-    ),
-    action: action?.case === "app"
-      ? { case: "app", value: workflowStepAppCallToProto(action.value)! }
-      : action?.case === "agent"
-        ? { case: "agent", value: workflowStepAgentTurnToProto(action.value)! }
-        : { case: undefined },
+    inputs: mapValues(step.inputs ?? {}, (value) => workflowValueToProto(value)!),
     when: workflowStepWhenToProto(step.when),
     timeoutSeconds: step.timeoutSeconds ?? 0,
     metadata: optionalStruct(step.metadata),
+    action: app !== undefined
+      ? { case: "app", value: workflowStepAppCallToProto(app)! }
+      : agent !== undefined
+        ? { case: "agent", value: workflowStepAgentTurnToProto(agent)! }
+        : { case: undefined },
   });
 }
 
-export function workflowStepFromProto(input: ProtoWorkflowStep): WorkflowStep {
-  const action: WorkflowStepActionKind = input.action.case === "app"
-    ? { case: "app" as const, value: workflowStepAppCallFromProto(input.action.value)! }
-    : input.action.case === "agent"
-      ? { case: "agent" as const, value: workflowStepAgentTurnFromProto(input.action.value)! }
-      : { case: undefined };
-  return {
+export function workflowStepFromProto(input?: ProtoWorkflowStep): WorkflowStep | undefined {
+  if (input === undefined) return undefined;
+  const app = input.action.case === "app" ? workflowStepAppCallFromProto(input.action.value) : undefined;
+  const agent = input.action.case === "agent" ? workflowStepAgentTurnFromProto(input.action.value) : undefined;
+  return workflowStep({
     id: input.id,
-    inputs: Object.fromEntries(
-      Object.entries(input.inputs).map(([key, value]) => [
-        key,
-        workflowValueFromProto(value)!,
-      ]),
-    ),
-    app: workflowStepAppAction(action),
-    agent: workflowStepAgentAction(action),
-    action,
+    inputs: mapValues(input.inputs, (value) => workflowValueFromProto(value)!),
     when: workflowStepWhenFromProto(input.when),
     timeoutSeconds: input.timeoutSeconds,
     metadata: optionalObjectFromStruct(input.metadata),
-  };
+    app,
+    agent,
+  });
 }
 
-export function boundWorkflowTargetToProto(
-  input?: BoundWorkflowTarget | undefined,
-): ProtoBoundWorkflowTarget | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  const target = boundWorkflowTarget(input);
-  return create(BoundWorkflowTargetSchema, {
-    steps: target.steps?.map(workflowStepToProto) ?? [],
+export function boundWorkflowTargetToProto(input?: BoundWorkflowTarget): ProtoBoundWorkflowTarget | undefined {
+  if (input === undefined) return undefined;
+  return create(BoundWorkflowTargetSchema, { steps: input.steps?.map(workflowStepToProto) ?? [] });
+}
+
+export function boundWorkflowTargetFromProto(input?: ProtoBoundWorkflowTarget): BoundWorkflowTarget | undefined {
+  if (input === undefined) return undefined;
+  return { steps: input.steps.map((step) => workflowStepFromProto(step)!) };
+}
+
+export function workflowScheduleActivationToProto(input?: WorkflowScheduleActivation): ProtoWorkflowScheduleActivation | undefined {
+  if (input === undefined) return undefined;
+  const schedule = workflowScheduleActivation(input);
+  return create(WorkflowScheduleActivationSchema, {
+    cron: schedule.cron ?? "",
+    timezone: schedule.timezone ?? "",
   });
 }
 
-export function boundWorkflowTargetFromProto(
-  input?: ProtoBoundWorkflowTarget | undefined,
-): BoundWorkflowTarget | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    steps: input.steps.map(workflowStepFromProto),
-  };
+export function workflowScheduleActivationFromProto(input?: ProtoWorkflowScheduleActivation): WorkflowScheduleActivation | undefined {
+  return input === undefined ? undefined : { cron: input.cron, timezone: input.timezone };
 }
 
-export function workflowEventToProto(input?: WorkflowEvent | undefined): ProtoWorkflowEvent | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return create(WorkflowEventSchema, {
-    id: input.id ?? "",
-    source: input.source ?? "",
-    specVersion: input.specVersion ?? "",
-    type: input.type ?? "",
-    subject: input.subject ?? "",
-    time: optionalTimestamp(input.time),
-    datacontenttype: input.datacontenttype ?? "",
-    data: optionalStruct(input.data),
-    extensions: Object.fromEntries(
-      Object.entries(input.extensions ?? {}).map(([key, value]) => [key, valueFromJson(value)]),
-    ),
+export function workflowEventMatchToProto(input?: WorkflowEventMatch): ProtoWorkflowEventMatch | undefined {
+  if (input === undefined) return undefined;
+  const match = workflowEventMatch(input);
+  return create(WorkflowEventMatchSchema, {
+    type: match.type ?? "",
+    source: match.source ?? "",
+    subject: match.subject ?? "",
   });
 }
 
-export function workflowEventFromProto(input?: ProtoWorkflowEvent | undefined): WorkflowEvent | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
+export function workflowEventMatchFromProto(input?: ProtoWorkflowEventMatch): WorkflowEventMatch | undefined {
+  return input === undefined ? undefined : { type: input.type, source: input.source, subject: input.subject };
+}
+
+export function workflowEventActivationToProto(input?: WorkflowEventActivation): ProtoWorkflowEventActivation | undefined {
+  if (input === undefined) return undefined;
+  return create(WorkflowEventActivationSchema, { match: workflowEventMatchToProto(input.match) });
+}
+
+export function workflowEventActivationFromProto(input?: ProtoWorkflowEventActivation): WorkflowEventActivation | undefined {
+  return input === undefined ? undefined : { match: workflowEventMatchFromProto(input.match) };
+}
+
+export function workflowActivationToProto(input: WorkflowActivation): ProtoWorkflowActivation {
+  const activation = workflowActivation(input);
+  return create(WorkflowActivationSchema, {
+    id: activation.id ?? "",
+    input: workflowValueToProto(activation.input),
+    paused: activation.paused ?? false,
+    trigger: activation.trigger?.case === "schedule"
+      ? { case: "schedule", value: workflowScheduleActivationToProto(activation.trigger.value)! }
+      : activation.trigger?.case === "event"
+        ? { case: "event", value: workflowEventActivationToProto(activation.trigger.value)! }
+        : { case: undefined },
+  });
+}
+
+export function workflowActivationFromProto(input?: ProtoWorkflowActivation): WorkflowActivation | undefined {
+  if (input === undefined) return undefined;
+  return workflowActivation({
     id: input.id,
-    source: input.source,
-    specVersion: input.specVersion,
-    type: input.type,
-    subject: input.subject,
-    time: optionalDate(input.time),
-    datacontenttype: input.datacontenttype,
-    data: optionalObjectFromStruct(input.data),
-    extensions: Object.fromEntries(
-      Object.entries(input.extensions).map(([key, value]) => [key, jsonFromValue(value) as JsonInput]),
-    ),
-  };
+    input: workflowValueFromProto(input.input),
+    paused: input.paused,
+    schedule: input.trigger.case === "schedule" ? workflowScheduleActivationFromProto(input.trigger.value) : undefined,
+    event: input.trigger.case === "event" ? workflowEventActivationFromProto(input.trigger.value) : undefined,
+  });
 }
 
-export function workflowSignalToProto(input?: WorkflowSignal | undefined): ProtoWorkflowSignal | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowDefinitionSpecToProto(input?: WorkflowDefinitionSpec): ProtoWorkflowDefinitionSpec | undefined {
+  if (input === undefined) return undefined;
+  const spec = workflowDefinitionSpec(input);
+  return create(WorkflowDefinitionSpecSchema, {
+    id: spec.id ?? "",
+    target: boundWorkflowTargetToProto(spec.target),
+    activations: spec.activations?.map(workflowActivationToProto) ?? [],
+    paused: spec.paused ?? false,
+    runAs: subjectToProto(spec.runAs),
+  });
+}
+
+export function workflowDefinitionToProto(input: WorkflowDefinition): ProtoWorkflowDefinition {
+  const definition = workflowDefinition(input);
+  return create(WorkflowDefinitionSchema, {
+    id: definition.id ?? "",
+    generation: BigInt(definition.generation ?? 0),
+    target: boundWorkflowTargetToProto(definition.target),
+    activations: definition.activations?.map(workflowActivationToProto) ?? [],
+    paused: definition.paused ?? false,
+    createdBySubjectId: definition.createdBySubjectId ?? "",
+    createdAt: optionalTimestamp(definition.createdAt),
+    updatedAt: optionalTimestamp(definition.updatedAt),
+    providerName: definition.providerName ?? "",
+    runAs: subjectToProto(definition.runAs),
+  });
+}
+
+export function workflowDefinitionFromProto(input?: ProtoWorkflowDefinition): WorkflowDefinition | undefined {
+  if (input === undefined) return undefined;
+  return workflowDefinition({
+    id: input.id,
+    generation: input.generation,
+    target: boundWorkflowTargetFromProto(input.target),
+    activations: input.activations.map((activation) => workflowActivationFromProto(activation)!),
+    paused: input.paused,
+    createdBySubjectId: input.createdBySubjectId,
+    createdAt: optionalDate(input.createdAt),
+    updatedAt: optionalDate(input.updatedAt),
+    providerName: input.providerName,
+    runAs: subjectFromProto(input.runAs),
+  });
+}
+
+export function workflowSignalToProto(input?: WorkflowSignal): ProtoWorkflowSignal | undefined {
+  if (input === undefined) return undefined;
   return create(WorkflowSignalSchema, {
     id: input.id ?? "",
     name: input.name ?? "",
     payload: optionalStruct(input.payload),
     metadata: optionalStruct(input.metadata),
-    createdBy: workflowActorToProto(input.createdBy),
+    createdBySubjectId: input.createdBySubjectId ?? "",
     createdAt: optionalTimestamp(input.createdAt),
     idempotencyKey: input.idempotencyKey ?? "",
     sequence: BigInt(input.sequence ?? 0),
   });
 }
 
-export function workflowSignalFromProto(input?: ProtoWorkflowSignal | undefined): WorkflowSignal | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
+export function workflowSignalFromProto(input?: ProtoWorkflowSignal): WorkflowSignal | undefined {
+  if (input === undefined) return undefined;
+  return workflowSignal({
     id: input.id,
     name: input.name,
     payload: optionalObjectFromStruct(input.payload),
     metadata: optionalObjectFromStruct(input.metadata),
-    createdBy: workflowActorFromProto(input.createdBy),
+    createdBySubjectId: input.createdBySubjectId,
     createdAt: optionalDate(input.createdAt),
     idempotencyKey: input.idempotencyKey,
     sequence: input.sequence,
-  };
+  });
 }
 
-export function workflowScheduleTriggerToProto(
-  input?: WorkflowScheduleTrigger | undefined,
-): ProtoWorkflowScheduleTrigger | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowEventToProto(input?: WorkflowEvent): ProtoWorkflowEvent | undefined {
+  if (input === undefined) return undefined;
+  return create(WorkflowEventSchema, {
+    id: input.id ?? "",
+    source: input.source ?? "",
+    specVersion: input.specVersion ?? "",
+    type: input.type ?? "",
+    subject: input.subject ?? "",
+    time: optionalTimestamp(input.time),
+    datacontenttype: input.datacontenttype ?? "",
+    data: optionalStruct(input.data),
+    extensions: mapValues(input.extensions ?? {}, valueFromJson),
+  });
+}
+
+export function workflowEventFromProto(input?: ProtoWorkflowEvent): WorkflowEvent | undefined {
+  if (input === undefined) return undefined;
+  return workflowEvent({
+    id: input.id,
+    source: input.source,
+    specVersion: input.specVersion,
+    type: input.type,
+    subject: input.subject,
+    time: optionalDate(input.time),
+    datacontenttype: input.datacontenttype,
+    data: optionalObjectFromStruct(input.data),
+    extensions: mapValues(input.extensions, (value) => jsonFromValue(value) as JsonInput),
+  });
+}
+
+export function workflowScheduleTriggerToProto(input?: WorkflowScheduleTrigger): ProtoWorkflowScheduleTrigger | undefined {
+  if (input === undefined) return undefined;
   return create(WorkflowScheduleTriggerSchema, {
-    scheduleId: input.scheduleId ?? "",
+    activationId: input.activationId ?? "",
     scheduledFor: optionalTimestamp(input.scheduledFor),
   });
 }
 
-export function workflowScheduleTriggerFromProto(
-  input?: ProtoWorkflowScheduleTrigger | undefined,
-): WorkflowScheduleTrigger | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    scheduleId: input.scheduleId,
-    scheduledFor: optionalDate(input.scheduledFor),
-  };
+export function workflowScheduleTriggerFromProto(input?: ProtoWorkflowScheduleTrigger): WorkflowScheduleTrigger | undefined {
+  return input === undefined ? undefined : workflowScheduleTrigger({ activationId: input.activationId, scheduledFor: optionalDate(input.scheduledFor) });
 }
 
-export function workflowEventTriggerInvocationToProto(
-  input?: WorkflowEventTriggerInvocation | undefined,
-): ProtoWorkflowEventTriggerInvocation | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowEventTriggerInvocationToProto(input?: WorkflowEventTriggerInvocation): ProtoWorkflowEventTriggerInvocation | undefined {
+  if (input === undefined) return undefined;
   return create(WorkflowEventTriggerInvocationSchema, {
-    triggerId: input.triggerId ?? "",
+    activationId: input.activationId ?? "",
     event: workflowEventToProto(input.event),
   });
 }
 
-export function workflowEventTriggerInvocationFromProto(
-  input?: ProtoWorkflowEventTriggerInvocation | undefined,
-): WorkflowEventTriggerInvocation | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    triggerId: input.triggerId,
-    event: workflowEventFromProto(input.event),
-  };
+export function workflowEventTriggerInvocationFromProto(input?: ProtoWorkflowEventTriggerInvocation): WorkflowEventTriggerInvocation | undefined {
+  return input === undefined ? undefined : workflowEventTriggerInvocation({ activationId: input.activationId, event: workflowEventFromProto(input.event) });
 }
 
-export function workflowRunTriggerToProto(
-  input?: WorkflowRunTrigger | undefined,
-): ProtoWorkflowRunTrigger | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowRunTriggerToProto(input?: WorkflowRunTrigger): ProtoWorkflowRunTrigger | undefined {
+  if (input === undefined) return undefined;
   const trigger = workflowRunTrigger(input);
-  const kind = trigger.kind;
-  switch (kind?.case) {
+  switch (trigger.kind?.case) {
     case "manual":
-      return create(WorkflowRunTriggerSchema, {
-        kind: { case: "manual", value: create(WorkflowManualTriggerSchema) },
-      });
+      return create(WorkflowRunTriggerSchema, { kind: { case: "manual", value: create(WorkflowManualTriggerSchema) } });
     case "schedule":
-      return create(WorkflowRunTriggerSchema, {
-        kind: { case: "schedule", value: workflowScheduleTriggerToProto(kind.value)! },
-      });
+      return create(WorkflowRunTriggerSchema, { kind: { case: "schedule", value: workflowScheduleTriggerToProto(trigger.kind.value)! } });
     case "event":
-      return create(WorkflowRunTriggerSchema, {
-        kind: { case: "event", value: workflowEventTriggerInvocationToProto(kind.value)! },
-      });
+      return create(WorkflowRunTriggerSchema, { kind: { case: "event", value: workflowEventTriggerInvocationToProto(trigger.kind.value)! } });
     default:
       return create(WorkflowRunTriggerSchema);
   }
 }
 
-export function workflowRunTriggerFromProto(
-  input?: ProtoWorkflowRunTrigger | undefined,
-): WorkflowRunTrigger | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
+export function workflowRunTriggerFromProto(input?: ProtoWorkflowRunTrigger): WorkflowRunTrigger | undefined {
+  if (input === undefined) return undefined;
   switch (input.kind.case) {
     case "manual":
       return { kind: { case: "manual", value: {} } };
@@ -2195,471 +1419,247 @@ export function workflowRunTriggerFromProto(
   }
 }
 
-export function boundWorkflowRunToProto(input: BoundWorkflowRun): ProtoBoundWorkflowRun {
-  return create(BoundWorkflowRunSchema, {
+export function workflowStepAttemptToProto(input: WorkflowStepAttempt): ProtoWorkflowStepAttempt {
+  return create(WorkflowStepAttemptSchema, {
     id: input.id ?? "",
-    status: input.status ?? WorkflowRunStatus.UNSPECIFIED,
-    target: boundWorkflowTargetToProto(input.target),
-    trigger: workflowRunTriggerToProto(input.trigger),
-    createdAt: optionalTimestamp(input.createdAt),
+    status: input.status ?? WorkflowStepStatus.UNSPECIFIED,
+    idempotencyKey: input.idempotencyKey ?? "",
+    input: input.input === undefined ? undefined : valueFromJson(input.input),
+    output: input.output === undefined ? undefined : valueFromJson(input.output),
+    statusMessage: input.statusMessage ?? "",
     startedAt: optionalTimestamp(input.startedAt),
     completedAt: optionalTimestamp(input.completedAt),
-    statusMessage: input.statusMessage ?? "",
-    resultBody: input.resultBody ?? "",
-    createdBy: workflowActorToProto(input.createdBy),
-    workflowKey: input.workflowKey ?? "",
-    providerName: input.providerName ?? "",
-    definitionId: input.definitionId ?? "",
   });
 }
 
-export function boundWorkflowRunFromProto(input?: ProtoBoundWorkflowRun | undefined): BoundWorkflowRun | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
+export function workflowStepAttemptFromProto(input?: ProtoWorkflowStepAttempt): WorkflowStepAttempt | undefined {
+  if (input === undefined) return undefined;
+  return workflowStepAttempt({
     id: input.id,
-    status: input.status as WorkflowRunStatus,
-    target: boundWorkflowTargetFromProto(input.target),
-    trigger: workflowRunTriggerFromProto(input.trigger),
-    createdAt: optionalDate(input.createdAt),
+    status: input.status as WorkflowStepStatus,
+    idempotencyKey: input.idempotencyKey,
+    input: input.input === undefined ? undefined : jsonFromValue(input.input) as JsonInput,
+    output: input.output === undefined ? undefined : jsonFromValue(input.output) as JsonInput,
+    statusMessage: input.statusMessage,
     startedAt: optionalDate(input.startedAt),
     completedAt: optionalDate(input.completedAt),
-    statusMessage: input.statusMessage,
-    resultBody: input.resultBody,
-    createdBy: workflowActorFromProto(input.createdBy),
-    workflowKey: input.workflowKey,
-    providerName: input.providerName,
-    definitionId: input.definitionId,
-  };
-}
-
-export function signalWorkflowRunResponseToProto(
-  input: SignalWorkflowRunResponse,
-): ProtoSignalWorkflowRunResponse {
-  return create(SignalWorkflowRunResponseSchema, {
-    run: input.run === undefined ? undefined : boundWorkflowRunToProto(input.run),
-    signal: input.signal === undefined ? undefined : workflowSignalToProto(input.signal),
-    startedRun: input.startedRun ?? false,
-    workflowKey: input.workflowKey ?? "",
   });
 }
 
-export function boundWorkflowScheduleToProto(input: BoundWorkflowSchedule): ProtoBoundWorkflowSchedule {
-  return create(BoundWorkflowScheduleSchema, {
-    id: input.id ?? "",
-    cron: input.cron ?? "",
-    timezone: input.timezone ?? "",
-    target: boundWorkflowTargetToProto(input.target),
-    paused: input.paused ?? false,
-    createdAt: optionalTimestamp(input.createdAt),
-    updatedAt: optionalTimestamp(input.updatedAt),
-    nextRunAt: optionalTimestamp(input.nextRunAt),
-    createdBy: workflowActorToProto(input.createdBy),
-    providerName: input.providerName ?? "",
-    definitionId: input.definitionId ?? "",
+export function workflowStepExecutionToProto(input: WorkflowStepExecution): ProtoWorkflowStepExecution {
+  return create(WorkflowStepExecutionSchema, {
+    stepId: input.stepId ?? "",
+    status: input.status ?? WorkflowStepStatus.UNSPECIFIED,
+    attempts: input.attempts?.map(workflowStepAttemptToProto) ?? [],
+    input: input.input === undefined ? undefined : valueFromJson(input.input),
+    output: input.output === undefined ? undefined : valueFromJson(input.output),
+    statusMessage: input.statusMessage ?? "",
+    skipReason: input.skipReason ?? "",
+    startedAt: optionalTimestamp(input.startedAt),
+    completedAt: optionalTimestamp(input.completedAt),
   });
 }
 
-export function boundWorkflowScheduleFromProto(
-  input?: ProtoBoundWorkflowSchedule | undefined,
-): BoundWorkflowSchedule | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
-    id: input.id,
-    cron: input.cron,
-    timezone: input.timezone,
-    target: boundWorkflowTargetFromProto(input.target),
-    paused: input.paused,
-    createdAt: optionalDate(input.createdAt),
-    updatedAt: optionalDate(input.updatedAt),
-    nextRunAt: optionalDate(input.nextRunAt),
-    createdBy: workflowActorFromProto(input.createdBy),
-    providerName: input.providerName,
-    definitionId: input.definitionId,
-  };
+export function workflowStepExecutionFromProto(input?: ProtoWorkflowStepExecution): WorkflowStepExecution | undefined {
+  if (input === undefined) return undefined;
+  return workflowStepExecution({
+    stepId: input.stepId,
+    status: input.status as WorkflowStepStatus,
+    attempts: input.attempts.map((attempt) => workflowStepAttemptFromProto(attempt)!),
+    input: input.input === undefined ? undefined : jsonFromValue(input.input) as JsonInput,
+    output: input.output === undefined ? undefined : jsonFromValue(input.output) as JsonInput,
+    statusMessage: input.statusMessage,
+    skipReason: input.skipReason,
+    startedAt: optionalDate(input.startedAt),
+    completedAt: optionalDate(input.completedAt),
+  });
 }
 
-export function boundWorkflowEventTriggerToProto(
-  input: BoundWorkflowEventTrigger,
-): ProtoBoundWorkflowEventTrigger {
-  return create(BoundWorkflowEventTriggerSchema, {
-    id: input.id ?? "",
-    match: workflowEventMatchToProto(input.match),
-    target: boundWorkflowTargetToProto(input.target),
-    paused: input.paused ?? false,
-    createdAt: optionalTimestamp(input.createdAt),
-    updatedAt: optionalTimestamp(input.updatedAt),
-    createdBy: workflowActorToProto(input.createdBy),
-    providerName: input.providerName ?? "",
-    definitionId: input.definitionId ?? "",
+export function workflowRunToProto(input: WorkflowRun): ProtoWorkflowRun {
+  const run = workflowRun(input);
+  return create(WorkflowRunSchema, {
+    id: run.id ?? "",
+    status: run.status ?? WorkflowRunStatus.UNSPECIFIED,
+    target: boundWorkflowTargetToProto(run.target),
+    trigger: workflowRunTriggerToProto(run.trigger),
+    createdAt: optionalTimestamp(run.createdAt),
+    startedAt: optionalTimestamp(run.startedAt),
+    completedAt: optionalTimestamp(run.completedAt),
+    statusMessage: run.statusMessage ?? "",
+    output: run.output === undefined ? undefined : valueFromJson(run.output),
+    createdBySubjectId: run.createdBySubjectId ?? "",
+    workflowKey: run.workflowKey ?? "",
+    providerName: run.providerName ?? "",
+    definitionId: run.definitionId ?? "",
+    runAs: subjectToProto(run.runAs),
+    input: optionalStruct(run.input),
+    definitionGeneration: BigInt(run.definitionGeneration ?? 0),
+    currentStepId: run.currentStepId ?? "",
+    steps: run.steps?.map(workflowStepExecutionToProto) ?? [],
   });
 }
 
-export function boundWorkflowEventTriggerFromProto(
-  input?: ProtoBoundWorkflowEventTrigger | undefined,
-): BoundWorkflowEventTrigger | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
+export function workflowRunFromProto(input?: ProtoWorkflowRun): WorkflowRun | undefined {
+  if (input === undefined) return undefined;
+  return workflowRun({
     id: input.id,
-    match: workflowEventMatchFromProto(input.match),
+    status: input.status as WorkflowRunStatus,
     target: boundWorkflowTargetFromProto(input.target),
-    paused: input.paused,
+    trigger: workflowRunTriggerFromProto(input.trigger),
     createdAt: optionalDate(input.createdAt),
-    updatedAt: optionalDate(input.updatedAt),
-    createdBy: workflowActorFromProto(input.createdBy),
+    startedAt: optionalDate(input.startedAt),
+    completedAt: optionalDate(input.completedAt),
+    statusMessage: input.statusMessage,
+    output: input.output === undefined ? undefined : jsonFromValue(input.output) as JsonInput,
+    createdBySubjectId: input.createdBySubjectId,
+    workflowKey: input.workflowKey,
     providerName: input.providerName,
     definitionId: input.definitionId,
-  };
+    runAs: subjectFromProto(input.runAs),
+    input: optionalObjectFromStruct(input.input),
+    definitionGeneration: input.definitionGeneration,
+    currentStepId: input.currentStepId,
+    steps: input.steps.map((step) => workflowStepExecutionFromProto(step)!),
+  });
 }
 
-export function boundWorkflowDefinitionToProto(input: BoundWorkflowDefinition) {
-  return create(BoundWorkflowDefinitionSchema, {
+export function workflowRunEventToProto(input: WorkflowRunEvent): ProtoWorkflowRunEvent {
+  return create(WorkflowRunEventSchema, {
     id: input.id ?? "",
-    target: boundWorkflowTargetToProto(input.target),
-    createdBy: workflowActorToProto(input.createdBy),
+    runId: input.runId ?? "",
+    stepId: input.stepId ?? "",
+    type: input.type ?? "",
+    data: optionalStruct(input.data),
     createdAt: optionalTimestamp(input.createdAt),
-    providerName: input.providerName ?? "",
   });
 }
 
-export function boundWorkflowDefinitionFromProto(
-  input?: ProtoBoundWorkflowDefinition | undefined,
-): BoundWorkflowDefinition | undefined {
-  if (input === undefined) {
-    return undefined;
-  }
-  return {
+export function workflowRunEventFromProto(input?: ProtoWorkflowRunEvent): WorkflowRunEvent | undefined {
+  if (input === undefined) return undefined;
+  return workflowRunEvent({
     id: input.id,
-    target: boundWorkflowTargetFromProto(input.target),
-    createdBy: workflowActorFromProto(input.createdBy),
+    runId: input.runId,
+    stepId: input.stepId,
+    type: input.type,
+    data: optionalObjectFromStruct(input.data),
     createdAt: optionalDate(input.createdAt),
-    providerName: input.providerName,
-  };
-}
-
-function startWorkflowProviderRunRequestFromProto(
-  input: ProtoStartWorkflowProviderRunRequest,
-): StartWorkflowProviderRunRequest {
-	return {
-		target: boundWorkflowTargetFromProto(input.target),
-		idempotencyKey: input.idempotencyKey,
-		createdBy: workflowActorFromProto(input.createdBy),
-		workflowKey: input.workflowKey,
-		definitionId: input.definitionId,
-	};
-}
-
-function getWorkflowProviderRunRequestFromProto(
-  input: ProtoGetWorkflowProviderRunRequest,
-): GetWorkflowProviderRunRequest {
-  return { runId: input.runId };
-}
-
-function listWorkflowProviderRunsRequestFromProto(
-  input: ProtoListWorkflowProviderRunsRequest,
-): ListWorkflowProviderRunsRequest {
-  return {
-    pageSize: input.pageSize,
-    pageToken: input.pageToken,
-    status: input.status as WorkflowRunStatus,
-    targetApp: input.targetApp,
-  };
+  });
 }
 
-function cancelWorkflowProviderRunRequestFromProto(
-  input: ProtoCancelWorkflowProviderRunRequest,
-): CancelWorkflowProviderRunRequest {
-  return { runId: input.runId, reason: input.reason };
+export function signalWorkflowRunResponseToProto(input: SignalWorkflowRunResponse): ProtoSignalWorkflowRunResponse {
+  return create(SignalWorkflowRunResponseSchema, {
+    run: workflowRunToProto(input.run ?? {}),
+    signal: workflowSignalToProto(input.signal),
+    startedRun: input.startedRun ?? false,
+    workflowKey: input.workflowKey ?? "",
+  });
 }
 
-function signalWorkflowProviderRunRequestFromProto(
-  input: ProtoSignalWorkflowProviderRunRequest,
-): SignalWorkflowProviderRunRequest {
+export function workflowRunSignalFromProto(input?: ProtoSignalWorkflowRunResponse): SignalWorkflowRunResponse | undefined {
+  if (input === undefined) return undefined;
   return {
-    runId: input.runId,
+    run: workflowRunFromProto(input.run),
     signal: workflowSignalFromProto(input.signal),
+    startedRun: input.startedRun,
+    workflowKey: input.workflowKey,
   };
 }
 
-function signalOrStartWorkflowProviderRunRequestFromProto(
-  input: ProtoSignalOrStartWorkflowProviderRunRequest,
-): SignalOrStartWorkflowProviderRunRequest {
+function applyWorkflowProviderDefinitionRequestFromProto(input: ProtoApplyWorkflowProviderDefinitionRequest): ApplyWorkflowProviderDefinitionRequest {
   return {
-    workflowKey: input.workflowKey,
-    target: boundWorkflowTargetFromProto(input.target),
+    spec: workflowDefinitionSpecFromProto(input.spec),
     idempotencyKey: input.idempotencyKey,
-    createdBy: workflowActorFromProto(input.createdBy),
-    signal: workflowSignalFromProto(input.signal),
-    definitionId: input.definitionId,
+    requestedBySubjectId: input.requestedBySubjectId,
   };
 }
 
-function createWorkflowProviderDefinitionRequestFromProto(
-  input: ProtoCreateWorkflowProviderDefinitionRequest,
-): CreateWorkflowProviderDefinitionRequest {
-	return {
-		target: boundWorkflowTargetFromProto(input.target),
-		idempotencyKey: input.idempotencyKey,
-		createdBy: workflowActorFromProto(input.createdBy),
-	};
+function getWorkflowProviderDefinitionRequestFromProto(input: ProtoGetWorkflowProviderDefinitionRequest): GetWorkflowProviderDefinitionRequest {
+  return { definitionId: input.definitionId };
 }
 
-function getWorkflowProviderDefinitionRequestFromProto(
-  input: ProtoGetWorkflowProviderDefinitionRequest,
-): GetWorkflowProviderDefinitionRequest {
-  return { definitionId: input.definitionId };
+function setWorkflowProviderDefinitionPausedRequestFromProto(input: ProtoSetWorkflowProviderDefinitionPausedRequest): SetWorkflowProviderDefinitionPausedRequest {
+  return { definitionId: input.definitionId, paused: input.paused, requestedBySubjectId: input.requestedBySubjectId };
 }
 
-function updateWorkflowProviderDefinitionRequestFromProto(
-  input: ProtoUpdateWorkflowProviderDefinitionRequest,
-): UpdateWorkflowProviderDefinitionRequest {
-  return {
-    definitionId: input.definitionId,
-    target: boundWorkflowTargetFromProto(input.target),
-    requestedBy: workflowActorFromProto(input.requestedBy),
-  };
+function setWorkflowProviderActivationPausedRequestFromProto(input: ProtoSetWorkflowProviderActivationPausedRequest): SetWorkflowProviderActivationPausedRequest {
+  return { definitionId: input.definitionId, activationId: input.activationId, paused: input.paused, requestedBySubjectId: input.requestedBySubjectId };
 }
 
-function deleteWorkflowProviderDefinitionRequestFromProto(
-  input: ProtoDeleteWorkflowProviderDefinitionRequest,
-): DeleteWorkflowProviderDefinitionRequest {
+function deleteWorkflowProviderDefinitionRequestFromProto(input: { definitionId: string }): DeleteWorkflowProviderDefinitionRequest {
   return { definitionId: input.definitionId };
 }
 
-function upsertWorkflowProviderScheduleRequestFromProto(
-  input: ProtoUpsertWorkflowProviderScheduleRequest,
-): UpsertWorkflowProviderScheduleRequest {
+function startWorkflowProviderRunRequestFromProto(input: ProtoStartWorkflowProviderRunRequest): StartWorkflowProviderRunRequest {
   return {
-    scheduleId: input.scheduleId,
-    cron: input.cron,
-    timezone: input.timezone,
-    target: boundWorkflowTargetFromProto(input.target),
-    paused: input.paused,
-    requestedBy: workflowActorFromProto(input.requestedBy),
-    idempotencyKey: input.idempotencyKey,
     definitionId: input.definitionId,
-  };
-}
-
-function getWorkflowProviderScheduleRequestFromProto(
-  input: ProtoGetWorkflowProviderScheduleRequest,
-): GetWorkflowProviderScheduleRequest {
-  return { scheduleId: input.scheduleId };
-}
-
-function listWorkflowProviderSchedulesRequestFromProto(
-  _input: ProtoListWorkflowProviderSchedulesRequest,
-): ListWorkflowProviderSchedulesRequest {
-  return {};
-}
-
-function deleteWorkflowProviderScheduleRequestFromProto(
-  input: ProtoDeleteWorkflowProviderScheduleRequest,
-): DeleteWorkflowProviderScheduleRequest {
-  return { scheduleId: input.scheduleId };
-}
-
-function pauseWorkflowProviderScheduleRequestFromProto(
-  input: ProtoPauseWorkflowProviderScheduleRequest,
-): PauseWorkflowProviderScheduleRequest {
-  return { scheduleId: input.scheduleId };
-}
-
-function resumeWorkflowProviderScheduleRequestFromProto(
-  input: ProtoResumeWorkflowProviderScheduleRequest,
-): ResumeWorkflowProviderScheduleRequest {
-  return { scheduleId: input.scheduleId };
-}
-
-function upsertWorkflowProviderEventTriggerRequestFromProto(
-  input: ProtoUpsertWorkflowProviderEventTriggerRequest,
-): UpsertWorkflowProviderEventTriggerRequest {
-  return {
-    triggerId: input.triggerId,
-    match: workflowEventMatchFromProto(input.match),
-    target: boundWorkflowTargetFromProto(input.target),
-    paused: input.paused,
-    requestedBy: workflowActorFromProto(input.requestedBy),
+    expectedDefinitionGeneration: input.expectedDefinitionGeneration,
+    input: optionalObjectFromStruct(input.input),
     idempotencyKey: input.idempotencyKey,
-    definitionId: input.definitionId,
-  };
-}
-
-function getWorkflowProviderEventTriggerRequestFromProto(
-  input: ProtoGetWorkflowProviderEventTriggerRequest,
-): GetWorkflowProviderEventTriggerRequest {
-  return { triggerId: input.triggerId };
-}
-
-function listWorkflowProviderEventTriggersRequestFromProto(
-  _input: ProtoListWorkflowProviderEventTriggersRequest,
-): ListWorkflowProviderEventTriggersRequest {
-  return {};
-}
-
-function deleteWorkflowProviderEventTriggerRequestFromProto(
-  input: ProtoDeleteWorkflowProviderEventTriggerRequest,
-): DeleteWorkflowProviderEventTriggerRequest {
-  return { triggerId: input.triggerId };
-}
-
-function pauseWorkflowProviderEventTriggerRequestFromProto(
-  input: ProtoPauseWorkflowProviderEventTriggerRequest,
-): PauseWorkflowProviderEventTriggerRequest {
-  return { triggerId: input.triggerId };
-}
-
-function resumeWorkflowProviderEventTriggerRequestFromProto(
-  input: ProtoResumeWorkflowProviderEventTriggerRequest,
-): ResumeWorkflowProviderEventTriggerRequest {
-  return { triggerId: input.triggerId };
-}
-
-function publishWorkflowProviderEventRequestFromProto(
-  input: ProtoPublishWorkflowProviderEventRequest,
-): PublishWorkflowProviderEventRequest {
-  return {
-    appName: input.appName,
-    event: workflowEventFromProto(input.event),
-    publishedBy: workflowActorFromProto(input.publishedBy),
-  };
-}
-
-export function workflowScheduleFromProto(
-  input: ProtoBoundWorkflowSchedule,
-): WorkflowSchedule {
-  return {
-    providerName: input.providerName,
-    schedule: boundWorkflowScheduleFromProto(input),
-  };
-}
-
-export function workflowEventTriggerFromProto(
-  input: ProtoBoundWorkflowEventTrigger,
-): WorkflowEventTrigger {
-  return {
-    providerName: input.providerName,
-    trigger: boundWorkflowEventTriggerFromProto(input),
-  };
-}
-
-export function workflowDefinitionFromProto(
-  input: ProtoBoundWorkflowDefinition,
-): WorkflowDefinition {
-  return {
-    providerName: input.providerName,
-    definition: boundWorkflowDefinitionFromProto(input),
+    createdBySubjectId: input.createdBySubjectId,
+    runAs: subjectInputFromProto(input.runAs),
+    workflowKey: input.workflowKey,
   };
 }
 
-export function workflowRunFromProto(
-  input: ProtoBoundWorkflowRun,
-): WorkflowRun {
-  return {
-    providerName: input.providerName,
-    run: boundWorkflowRunFromProto(input),
-  };
+function getWorkflowProviderRunRequestFromProto(input: ProtoGetWorkflowProviderRunRequest): GetWorkflowProviderRunRequest {
+  return { runId: input.runId };
 }
 
-export function workflowRunSignalFromProto(
-  input: ProtoSignalWorkflowRunResponse,
-): WorkflowRunSignal {
+function listWorkflowProviderRunsRequestFromProto(input: ProtoListWorkflowProviderRunsRequest): ListWorkflowProviderRunsRequest {
   return {
-    providerName: input.run?.providerName,
-    run: boundWorkflowRunFromProto(input.run),
-    signal: workflowSignalFromProto(input.signal),
-    startedRun: input.startedRun,
-    workflowKey: input.workflowKey,
+    pageSize: input.pageSize,
+    pageToken: input.pageToken,
+    status: input.status as WorkflowRunStatus,
+    targetApp: input.targetApp,
   };
 }
 
-function cloneWorkflowValueKind(kind: WorkflowValueKind): WorkflowValueKind {
-  switch (kind.case) {
-    case "literal":
-      return { case: "literal", value: jsonClone(kind.value) };
-    case "object":
-      return {
-        case: "object",
-        value: Object.fromEntries(
-          Object.entries(kind.value).map(([key, value]) => [key, workflowValue(value)]),
-        ),
-      };
-    case "array":
-      return { case: "array", value: kind.value.map(workflowValue) };
-    case "template":
-      return { case: "template", value: workflowText(kind.value) };
-    case "runInput":
-    case "signalPayload":
-      return { case: kind.case, value: kind.value };
-    case "stepOutput":
-      return { case: "stepOutput", value: workflowStepOutputSource(kind.value) };
-    default:
-      return { case: undefined };
-  }
-}
-
-function valueMapInput(input?: Record<string, JsonInput>): Record<string, JsonInput> {
-  return input === undefined ? {} : { ...input };
-}
-
-function workflowAgentOutputInputFromOutput(
-  input: AgentOutput,
-): AgentOutput {
-  if (input.text !== undefined) {
-    return { text: {} };
-  }
-  if (input.structured !== undefined) {
-    return {
-      structured: {
-        schema: jsonObjectClone(input.structured.schema),
-      },
-    };
-  }
-  throw new Error("workflow agent output is required");
+function getWorkflowProviderRunEventsRequestFromProto(input: ProtoGetWorkflowProviderRunEventsRequest): GetWorkflowProviderRunEventsRequest {
+  return { runId: input.runId };
 }
-
-function jsonObjectClone(input: JsonObjectInput): JsonObjectInput {
-  return structFromObject(jsonObjectFromStruct(input as JsonObject));
+
+function getWorkflowProviderRunOutputRequestFromProto(input: ProtoGetWorkflowProviderRunOutputRequest): GetWorkflowProviderRunOutputRequest {
+  return { runId: input.runId };
 }
 
-function jsonClone(input: JsonInput): JsonInput {
-  return jsonFromValue(valueFromJson(input)) as JsonInput;
+function cancelWorkflowProviderRunRequestFromProto(input: ProtoCancelWorkflowProviderRunRequest): CancelWorkflowProviderRunRequest {
+  return { runId: input.runId, reason: input.reason };
 }
 
-function optionalTimestamp(value?: Date | undefined) {
-  return value === undefined ? undefined : timestampFromDate(value);
+function signalWorkflowProviderRunRequestFromProto(input: ProtoSignalWorkflowProviderRunRequest): SignalWorkflowProviderRunRequest {
+  return { runId: input.runId, signal: workflowSignalFromProto(input.signal) };
 }
 
-function optionalDate(timestamp?: Parameters<typeof dateFromTimestamp>[0]) {
-  return timestamp === undefined ? undefined : dateFromTimestamp(timestamp);
+function signalOrStartWorkflowProviderRunRequestFromProto(input: ProtoSignalOrStartWorkflowProviderRunRequest): SignalOrStartWorkflowProviderRunRequest {
+  return {
+    workflowKey: input.workflowKey,
+    definitionId: input.definitionId,
+    expectedDefinitionGeneration: input.expectedDefinitionGeneration,
+    input: optionalObjectFromStruct(input.input),
+    idempotencyKey: input.idempotencyKey,
+    createdBySubjectId: input.createdBySubjectId,
+    runAs: subjectInputFromProto(input.runAs),
+    signal: workflowSignalFromProto(input.signal),
+  };
 }
 
-function listRunsResult(
-  value: readonly BoundWorkflowRun[] | ListWorkflowProviderRunsResponse,
-): ListWorkflowProviderRunsResponse {
-  return "runs" in value ? value : { runs: value };
+function deliverWorkflowProviderEventRequestFromProto(input: ProtoDeliverWorkflowProviderEventRequest): DeliverWorkflowProviderEventRequest {
+  return {
+    appName: input.appName,
+    event: workflowEventFromProto(input.event),
+    deliveredBySubjectId: input.deliveredBySubjectId,
+  };
 }
 
-async function invokeWorkflowProvider<T>(
-  action: string,
-  fn: () => Promise<T>,
-): Promise<T> {
-  try {
-    return await fn();
-  } catch (error) {
-    if (error instanceof ConnectError) {
-      throw error;
-    }
-    throw new ConnectError(
-      `workflow provider ${action}: ${errorMessage(error)}`,
-      Code.Unknown,
-    );
-  }
+export function workflowDefinitionSpecFromProto(input?: ProtoWorkflowDefinitionSpec): WorkflowDefinitionSpec | undefined {
+  if (input === undefined) return undefined;
+  return workflowDefinitionSpec({
+    id: input.id,
+    target: boundWorkflowTargetFromProto(input.target),
+    activations: input.activations.map((activation) => workflowActivationFromProto(activation)!),
+    paused: input.paused,
+    runAs: subjectInputFromProto(input.runAs),
+  });
 }
 
 export interface WorkflowExecutionRequest {
@@ -2669,23 +1669,16 @@ export interface WorkflowExecutionRequest {
   trigger?: WorkflowRunTrigger | undefined;
   input?: Record<string, JsonInput> | undefined;
   metadata?: Record<string, JsonInput> | undefined;
-  createdBy?: WorkflowActor | undefined;
+  createdBySubjectId?: string | undefined;
   invocationToken?: string | undefined;
   signals?: readonly WorkflowSignal[] | undefined;
-}
-
-export interface WorkflowRunContextActor {
-  subjectId: string;
-  subjectKind: string;
-  displayName: string;
-  authSource: string;
+  steps?: Record<string, { inputs?: Record<string, unknown>; outputs?: unknown }> | undefined;
 }
 
 export interface WorkflowRunContextTrigger {
   kind: string;
-  scheduleId: string;
+  activationId: string;
   scheduledFor: string;
-  triggerId: string;
   event?: Record<string, JsonInput> | undefined;
 }
 
@@ -2694,7 +1687,7 @@ export interface WorkflowRunContextSignal {
   name: string;
   payload: Record<string, JsonInput>;
   metadata: Record<string, JsonInput>;
-  createdBy?: WorkflowRunContextActor | undefined;
+  createdBySubjectId: string;
   createdAt: string;
   idempotencyKey: string;
   sequence?: number | undefined;
@@ -2708,7 +1701,7 @@ export interface WorkflowRunContext {
   input: Record<string, JsonInput>;
   metadata: Record<string, JsonInput>;
   signals: readonly WorkflowRunContextSignal[];
-  createdBy?: WorkflowRunContextActor | undefined;
+  createdBySubjectId: string;
   latestSignal?: WorkflowRunContextSignal | undefined;
 }
 
@@ -2721,469 +1714,272 @@ export interface WorkflowEvalContext {
 
 export class WorkflowValueError extends Error {}
 
-export function evaluateWorkflowStepInputs(
-  ctx: WorkflowEvalContext,
-  values?: Record<string, WorkflowValue> | undefined,
-): Record<string, unknown> | undefined {
-  if (values === undefined || Object.keys(values).length === 0) {
-    return undefined;
-  }
+export function evaluateWorkflowStepInputs(ctx: WorkflowEvalContext, values?: Record<string, WorkflowValue>): Record<string, unknown> | undefined {
+  if (values === undefined || Object.keys(values).length === 0) return undefined;
   const out: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(values)) {
     const resolved = evaluateWorkflowValue(ctx, value);
-    if (!resolved.ok) {
-      throw new WorkflowValueError(`inputs.${key} did not resolve`);
-    }
+    if (!resolved.ok) throw new WorkflowValueError(`inputs.${key} did not resolve`);
     out[key] = resolved.value;
   }
   return out;
 }
 
-export function evaluateWorkflowValue(
-  ctx: WorkflowEvalContext,
-  input: WorkflowValue,
-): { value: unknown; ok: boolean } {
-  const value = workflowValue(input);
-  const kind = value.kind;
+export function evaluateWorkflowValue(ctx: WorkflowEvalContext, input: WorkflowValue): { value: unknown; ok: boolean } {
+  const kind = workflowValue(input).kind;
   switch (kind?.case) {
     case "literal":
-      return { value: kind.value, ok: true };
+      return { value: jsonClone(kind.value), ok: true };
     case "object": {
       const out: Record<string, unknown> = {};
-      for (const [key, child] of Object.entries(kind.value)) {
-        const resolved = evaluateWorkflowValue(ctx, child);
-        if (!resolved.ok) {
-          return { value: undefined, ok: false };
-        }
+      for (const [key, value] of Object.entries(kind.value)) {
+        const resolved = evaluateWorkflowValue(ctx, value);
+        if (!resolved.ok) return resolved;
         out[key] = resolved.value;
       }
       return { value: out, ok: true };
     }
     case "array": {
       const out: unknown[] = [];
-      for (const child of kind.value) {
-        const resolved = evaluateWorkflowValue(ctx, child);
-        if (!resolved.ok) {
-          return { value: undefined, ok: false };
-        }
+      for (const value of kind.value) {
+        const resolved = evaluateWorkflowValue(ctx, value);
+        if (!resolved.ok) return resolved;
         out.push(resolved.value);
       }
       return { value: out, ok: true };
     }
     case "template":
-      return {
-        value: renderWorkflowTemplate(
-          ctx,
-          typeof kind.value === "string" ? kind.value : (kind.value.template ?? ""),
-        ),
-        ok: true,
-      };
-    case "runInput":
-      return mapPathValue(ctx.request.input, kind.value);
-    case "signalPayload": {
+      return { value: renderWorkflowTemplate(ctx, workflowText(kind.value).template ?? ""), ok: true };
+    case "input":
+      return mapPathValue(ctx.request.input ?? {}, kind.value);
+    case "signal": {
       const signal = latestWorkflowSignal(ctx.request.signals);
-      return signal === undefined
-        ? { value: undefined, ok: false }
-        : pathValue(signal.payload, kind.value);
-    }
-    case "stepOutput": {
-      const stepId = kind.value.stepId?.trim() ?? "";
-      const outputs = ctx.outputs ?? {};
-      if (!Object.prototype.hasOwnProperty.call(outputs, stepId)) {
-        throw new WorkflowValueError(
-          `workflow step output references missing step "${stepId}"`,
-        );
-      }
-      return pathValue(outputs[stepId], kind.value.path ?? "");
+      return signal === undefined ? { value: undefined, ok: false } : pathValue(signal.payload, kind.value);
     }
+    case "stepOutput":
+      return pathValue(ctx.outputs?.[kind.value.stepId ?? ""], kind.value.path ?? "");
+    case "stepInput":
+      return pathValue(ctx.request.steps?.[kind.value.stepId ?? ""]?.inputs, kind.value.path ?? "");
     default:
-      return { value: undefined, ok: true };
+      return { value: undefined, ok: false };
   }
 }
 
-export function renderWorkflowTemplate(
-  ctx: WorkflowEvalContext,
-  template: string,
-): string {
-  let out = "";
-  for (let i = 0; i < template.length; ) {
-    if (template.startsWith("$${", i)) {
-      out += "${";
-      i += 3;
+export function renderWorkflowTemplate(ctx: WorkflowEvalContext, template: string): string {
+  return template.replace(/\$\$\{/g, "\u0000{").replace(/\$\{([^{}]+)\}/g, (_match, expr: string) => {
+    const resolved = templateExpressionValue(ctx, expr.trim());
+    if (!resolved.ok) throw new WorkflowValueError(`template expression "${expr.trim()}" did not resolve`);
+    return renderTemplateValue(resolved.value);
+  }).replace(/\u0000\{/g, "${");
+}
+
+export function pathValue(value: unknown, path: string): { value: unknown; ok: boolean } {
+  let current = value;
+  if (path.trim() === "") return { value: current, ok: true };
+  for (const segment of pathSegments(path)) {
+    if (current !== null && typeof current === "object" && typeof segment === "string") {
+      if (!Object.prototype.hasOwnProperty.call(current, segment)) return { value: undefined, ok: false };
+      current = (current as Record<string, unknown>)[segment];
       continue;
     }
-    if (!template.startsWith("${", i)) {
-      out += template[i];
-      i += 1;
+    if (typeof segment === "number" && Array.isArray(current)) {
+      if (segment < 0 || segment >= current.length) return { value: undefined, ok: false };
+      current = current[segment];
       continue;
     }
-    const end = template.indexOf("}", i + 2);
-    if (end < 0) {
-      throw new WorkflowValueError("unterminated template expression");
-    }
-    const expr = template.slice(i + 2, end).trim();
-    const resolved = templateExpressionValue(ctx, expr);
-    if (!resolved.ok) {
-      throw new WorkflowValueError(`template expression "${expr}" did not resolve`);
-    }
-    out += renderTemplateValue(resolved.value);
-    i = end + 1;
+    return { value: undefined, ok: false };
   }
-  return out;
+  return { value: current, ok: true };
 }
 
-export function workflowRunContext(
-  req: WorkflowExecutionRequest,
-): Record<string, JsonInput> {
-  const out: Record<string, JsonInput> = {};
-  if (req.runId?.trim()) {
-    out.runId = req.runId.trim();
-  }
-  if (req.providerName?.trim()) {
-    out.provider = req.providerName.trim();
-  }
-  const target = workflowTargetContext(req.target);
-  if (target !== undefined) {
-    out.target = target;
-  }
-  const trigger = workflowTriggerContext(req.trigger);
-  if (trigger !== undefined) {
-    out.trigger = trigger;
-  }
-  if (req.input !== undefined) {
-    out.input = { ...req.input };
-  }
-  if (req.metadata !== undefined) {
-    out.metadata = { ...req.metadata };
-  }
-  const signals = workflowSignalsContext(req.signals);
-  if (signals.length > 0) {
-    out.signals = signals;
-  }
-  const createdBy = workflowActorContext(req.createdBy);
-  if (createdBy !== undefined) {
-    out.createdBy = createdBy;
-  }
-  return out;
+export function workflowRunContext(input: WorkflowExecutionRequest = {}): WorkflowRunContext {
+  const signals = workflowSignalsContext(input.signals);
+  return {
+    provider: input.providerName ?? "",
+    runId: input.runId ?? "",
+    target: workflowTargetContext(input.target),
+    trigger: workflowTriggerContext(input.trigger),
+    input: valueMapInput(input.input),
+    metadata: valueMapInput(input.metadata),
+    createdBySubjectId: input.createdBySubjectId ?? "",
+    signals,
+    latestSignal: signals.at(-1),
+  };
 }
 
-export function parseWorkflowRunContext(
-  value?: Request | Record<string, unknown> | null | undefined,
-): WorkflowRunContext {
+export function parseWorkflowRunContext(value: unknown): WorkflowRunContext {
   const data = workflowRunContextData(value);
-  const target = workflowContextOptionalObject(data.target);
   const signals = Array.isArray(data.signals)
-    ? data.signals
-      .map(workflowRunContextSignal)
-      .filter((signal): signal is WorkflowRunContextSignal => signal !== undefined)
+    ? data.signals.map(workflowRunContextSignal).filter((signal): signal is WorkflowRunContextSignal => signal !== undefined)
     : [];
-  const createdBy = workflowRunContextActor(data.createdBy);
-  const latestSignal = signals.at(-1);
-  const context: WorkflowRunContext = {
-    provider: workflowContextString(data.provider),
+  return {
+    provider: workflowContextString(data.provider ?? data.providerName),
     runId: workflowContextString(data.runId),
+    target: workflowContextOptionalObject(data.target),
     trigger: workflowRunContextTrigger(data.trigger),
     input: workflowContextObject(data.input),
     metadata: workflowContextObject(data.metadata),
+    createdBySubjectId: workflowContextString(data.createdBySubjectId),
     signals,
+    latestSignal: signals.at(-1),
   };
-  if (target !== undefined) {
-    context.target = target;
-  }
-  if (createdBy !== undefined) {
-    context.createdBy = createdBy;
-  }
-  if (latestSignal !== undefined) {
-    context.latestSignal = latestSignal;
-  }
-  return context;
 }
 
-function workflowRunContextData(
-  value?: Request | Record<string, unknown> | null | undefined,
-): Record<string, unknown> {
-  if (!isWorkflowContextRecord(value)) {
-    return {};
-  }
-  return isWorkflowContextRecord(value.workflow) ? value.workflow : value;
+export function workflowSignalsContext(signals?: readonly WorkflowSignal[]): readonly WorkflowRunContextSignal[] {
+  return (signals ?? []).map((signal) => ({
+    id: signal.id ?? "",
+    name: signal.name ?? "",
+    payload: compactWorkflowSignalPayload(signal.payload ?? {}),
+    metadata: valueMapInput(signal.metadata as Record<string, JsonInput> | undefined),
+    createdBySubjectId: signal.createdBySubjectId ?? "",
+    createdAt: signal.createdAt?.toISOString() ?? "",
+    idempotencyKey: signal.idempotencyKey ?? "",
+    sequence: typeof signal.sequence === "number" ? signal.sequence : typeof signal.sequence === "bigint" ? Number(signal.sequence) : undefined,
+  }));
 }
 
-function workflowRunContextTrigger(value: unknown): WorkflowRunContextTrigger {
-  const data = isWorkflowContextRecord(value) ? value : {};
-  const event = workflowContextOptionalObject(data.event);
-  const trigger: WorkflowRunContextTrigger = {
-    kind: workflowContextString(data.kind),
-    scheduleId: workflowContextString(data.scheduleId),
-    scheduledFor: workflowContextString(data.scheduledFor),
-    triggerId: workflowContextString(data.triggerId),
-  };
-  if (event !== undefined) {
-    trigger.event = event;
-  }
-  return trigger;
+export function subjectToProto(input?: SubjectInput | Subject): SubjectContext | undefined {
+  if (input === undefined) return undefined;
+  return create(SubjectContextSchema, {
+    id: input.id ?? "",
+    credentialSubjectId: input.credentialSubjectId ?? "",
+    email: input.email ?? "",
+  });
 }
 
-function workflowRunContextSignal(value: unknown): WorkflowRunContextSignal | undefined {
-  if (!isWorkflowContextRecord(value)) {
-    return undefined;
-  }
-  const signal: WorkflowRunContextSignal = {
-    id: workflowContextString(value.id),
-    name: workflowContextString(value.name),
-    payload: workflowContextObject(value.payload),
-    metadata: workflowContextObject(value.metadata),
-    createdAt: workflowContextString(value.createdAt),
-    idempotencyKey: workflowContextString(value.idempotencyKey),
+export function subjectFromProto(input?: SubjectContext): Subject | undefined {
+  if (input === undefined) return undefined;
+  return {
+    id: input.id,
+    credentialSubjectId: input.credentialSubjectId,
+    email: input.email,
   };
-  const createdBy = workflowRunContextActor(value.createdBy);
-  if (createdBy !== undefined) {
-    signal.createdBy = createdBy;
-  }
-  const sequence = workflowContextNumber(value.sequence);
-  if (sequence !== undefined) {
-    signal.sequence = sequence;
-  }
-  return signal;
 }
 
-function workflowRunContextActor(value: unknown): WorkflowRunContextActor | undefined {
-  if (!isWorkflowContextRecord(value)) {
-    return undefined;
-  }
-  const actor: WorkflowRunContextActor = {
-    subjectId: workflowContextString(value.subjectId),
-    subjectKind: workflowContextString(value.subjectKind),
-    displayName: workflowContextString(value.displayName),
-    authSource: workflowContextString(value.authSource),
+export function subjectInputFromProto(input?: SubjectContext): SubjectInput | undefined {
+  if (input === undefined) return undefined;
+  return {
+    id: input.id,
+    credentialSubjectId: input.credentialSubjectId,
+    email: input.email,
   };
-  return actor.subjectId || actor.subjectKind || actor.displayName || actor.authSource
-    ? actor
-    : undefined;
 }
 
-function workflowContextString(value: unknown): string {
-  return typeof value === "string" ? value.trim() : "";
+function listDefinitionsResult(value: readonly WorkflowDefinition[] | ListWorkflowProviderDefinitionsResponse): ListWorkflowProviderDefinitionsResponse {
+  return "definitions" in value ? value : { definitions: value };
 }
 
-function workflowContextNumber(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+function listRunsResult(value: readonly WorkflowRun[] | ListWorkflowProviderRunsResponse): ListWorkflowProviderRunsResponse {
+  return "runs" in value ? value : { runs: value };
 }
 
-function workflowContextObject(value: unknown): Record<string, JsonInput> {
-  return isWorkflowContextRecord(value) ? { ...(value as Record<string, JsonInput>) } : {};
+function runEventsResult(value: readonly WorkflowRunEvent[] | GetWorkflowProviderRunEventsResponse): GetWorkflowProviderRunEventsResponse {
+  return "events" in value ? value : { events: value };
 }
 
-function workflowContextOptionalObject(value: unknown): Record<string, JsonInput> | undefined {
-  return isWorkflowContextRecord(value) ? { ...(value as Record<string, JsonInput>) } : undefined;
+function runOutputResult(value: JsonInput | GetWorkflowProviderRunOutputResponse): GetWorkflowProviderRunOutputResponse {
+  return value !== null && typeof value === "object" && "output" in value ? value : { output: value };
 }
 
-function isWorkflowContextRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+async function invokeWorkflowProvider<T>(action: string, fn: () => Promise<T> | T): Promise<T> {
+  try {
+    return await fn();
+  } catch (error) {
+    if (error instanceof ConnectError) throw error;
+    throw new ConnectError(`workflow provider ${action}: ${errorMessage(error)}`, Code.Unknown);
+  }
 }
 
-function workflowTargetContext(
-  target?: BoundWorkflowTarget,
-): Record<string, JsonInput> | undefined {
-  if (target?.steps === undefined || target.steps.length === 0) {
-    return undefined;
-  }
-  return {
-    kind: "steps",
-    steps: target.steps.map((step) => {
-      const item: Record<string, JsonInput> = { id: step.id?.trim() ?? "" };
-      const app = step.app ?? workflowStepAppAction(step.action);
-      const agent = step.agent ?? workflowStepAgentAction(step.action);
-      if (app !== undefined) {
-        item.kind = "app";
-        item.app = app.name?.trim() ?? "";
-        item.operation = app.operation?.trim() ?? "";
-        if (app.connection?.trim()) item.connection = app.connection.trim();
-        if (app.instance?.trim()) item.instance = app.instance.trim();
-        if (app.credentialMode?.trim()) item.credentialMode = app.credentialMode.trim();
-        return item;
-      }
-      if (agent !== undefined) {
-        item.kind = "agent";
-        item.agentProvider = agent.provider?.trim() ?? "";
-        item.model = agent.model?.trim() ?? "";
-        return item;
-      }
-      item.kind = "unknown";
-      return item;
-    }),
-  };
+function jsonObjectClone(input: JsonObjectInput): JsonObjectInput {
+  return structFromObject(jsonObjectFromStruct(input as JsonObject));
 }
 
-function workflowTriggerContext(
-  trigger?: WorkflowRunTrigger,
-): Record<string, JsonInput> | undefined {
-  if (trigger === undefined) {
-    return undefined;
-  }
-  const normalized = workflowRunTrigger(trigger);
-  switch (normalized.kind?.case) {
-    case "schedule": {
-      const value: Record<string, JsonInput> = {
-        kind: "schedule",
-        scheduleId: normalized.kind.value.scheduleId ?? "",
-      };
-      if (normalized.kind.value.scheduledFor !== undefined) {
-        value.scheduledFor = normalized.kind.value.scheduledFor.toISOString();
-      }
-      return value;
-    }
-    case "event": {
-      const value: Record<string, JsonInput> = {
-        kind: "event",
-        triggerId: normalized.kind.value.triggerId ?? "",
-      };
-      const event = workflowEventContext(normalized.kind.value.event);
-      if (event !== undefined) {
-        value.event = event;
-      }
-      return value;
-    }
-    case "manual":
-      return { kind: "manual" };
-    default:
-      return undefined;
-  }
+function jsonClone(input: JsonInput): JsonInput {
+  return jsonFromValue(valueFromJson(input)) as JsonInput;
 }
 
-function workflowEventContext(event?: WorkflowEvent): Record<string, JsonInput> | undefined {
-  if (event === undefined) {
-    return undefined;
-  }
-  const out: Record<string, JsonInput> = {};
-  if (event.id?.trim()) out.id = event.id.trim();
-  if (event.source?.trim()) out.source = event.source.trim();
-  if (event.specVersion?.trim()) out.specVersion = event.specVersion.trim();
-  if (event.type?.trim()) out.type = event.type.trim();
-  if (event.subject?.trim()) out.subject = event.subject.trim();
-  if (event.time !== undefined) out.time = event.time.toISOString();
-  if (event.datacontenttype?.trim()) out.dataContentType = event.datacontenttype.trim();
-  if (event.data !== undefined) out.data = jsonClone(event.data);
-  if (event.extensions !== undefined) out.extensions = { ...event.extensions };
-  return Object.keys(out).length === 0 ? undefined : out;
-}
-
-function workflowActorContext(actor?: WorkflowActor): Record<string, JsonInput> | undefined {
-  if (actor === undefined) {
-    return undefined;
-  }
-  const out: Record<string, JsonInput> = {};
-  if (actor.subjectId?.trim()) out.subjectId = actor.subjectId.trim();
-  if (actor.subjectKind?.trim()) out.subjectKind = actor.subjectKind.trim();
-  if (actor.displayName?.trim()) out.displayName = actor.displayName.trim();
-  if (actor.authSource?.trim()) out.authSource = actor.authSource.trim();
-  return Object.keys(out).length === 0 ? undefined : out;
-}
-
-export function workflowSignalsContext(
-  signals?: readonly WorkflowSignal[] | undefined,
-): Array<Record<string, JsonInput>> {
-  return (signals ?? []).slice(0, 10).map((signal) => {
-    const out: Record<string, JsonInput> = {};
-    if (signal.id?.trim()) out.id = signal.id.trim();
-    if (signal.name?.trim()) out.name = signal.name.trim();
-    if (signal.payload !== undefined) {
-      const payload = compactWorkflowSignalPayload(signal.payload);
-      if (Object.keys(payload).length > 0) out.payload = payload;
-    }
-    if (signal.metadata !== undefined) out.metadata = compactJsonValue(signal.metadata, 4);
-    const createdBy = workflowActorContext(signal.createdBy);
-    if (createdBy !== undefined) out.createdBy = createdBy;
-    if (signal.createdAt !== undefined) out.createdAt = signal.createdAt.toISOString();
-    if (signal.idempotencyKey?.trim()) {
-      out.idempotencyKey = signal.idempotencyKey.trim();
-    }
-    if (signal.sequence !== undefined && signal.sequence !== 0) {
-      out.sequence = Number(signal.sequence);
-    }
-    return out;
-  });
+function optionalTimestamp(value?: Date) {
+  return value === undefined ? undefined : timestampFromDate(value);
 }
 
-export function latestWorkflowSignal(
-  signals?: readonly WorkflowSignal[] | undefined,
-): WorkflowSignal | undefined {
-  return signals === undefined || signals.length === 0
-    ? undefined
-    : signals[signals.length - 1];
+function optionalDate(timestamp?: Parameters<typeof dateFromTimestamp>[0]) {
+  return timestamp === undefined ? undefined : dateFromTimestamp(timestamp);
 }
 
-export function mapPathValue(
-  values: Record<string, unknown> | undefined,
-  path: string,
-): { value: unknown; ok: boolean } {
-  return values === undefined || Object.keys(values).length === 0
-    ? { value: undefined, ok: false }
-    : pathValue(values, path);
+function mapValues<T, U>(input: Record<string, T>, fn: (value: T, key: string) => U): Record<string, U> {
+  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, fn(value, key)]));
 }
 
-export function pathValue(
-  root: unknown,
-  path: string,
-): { value: unknown; ok: boolean } {
-  const trimmed = path.trim();
-  if (!trimmed) {
-    return { value: root, ok: true };
+function cloneWorkflowValueKind(kind: WorkflowValueKind): WorkflowValueKind {
+  switch (kind.case) {
+    case "literal":
+      return { case: "literal", value: jsonClone(kind.value) };
+    case "object":
+      return { case: "object", value: mapValues(kind.value, workflowValue) };
+    case "array":
+      return { case: "array", value: kind.value.map(workflowValue) };
+    case "template":
+      return { case: "template", value: workflowText(kind.value) };
+    case "input":
+    case "signal":
+      return { case: kind.case, value: kind.value };
+    case "stepOutput":
+      return { case: "stepOutput", value: workflowStepOutputSource(kind.value) };
+    case "stepInput":
+      return { case: "stepInput", value: workflowStepInputSource(kind.value) };
+    default:
+      return { case: undefined };
   }
-  let current = root;
-  for (const segment of pathSegments(trimmed)) {
-    if (
-      typeof segment === "string" &&
-      current !== null &&
-      typeof current === "object" &&
-      !Array.isArray(current)
-    ) {
-      if (!Object.prototype.hasOwnProperty.call(current, segment)) {
-        return { value: undefined, ok: false };
-      }
-      current = (current as Record<string, unknown>)[segment];
-      continue;
-    }
-    if (typeof segment === "number" && Array.isArray(current)) {
-      if (segment < 0 || segment >= current.length) {
-        return { value: undefined, ok: false };
-      }
-      current = current[segment];
-      continue;
-    }
-    return { value: undefined, ok: false };
+}
+
+function cloneWorkflowRunTriggerKind(kind: WorkflowRunTriggerKind): WorkflowRunTriggerKind {
+  switch (kind.case) {
+    case "manual":
+      return { case: "manual", value: {} };
+    case "schedule":
+      return { case: "schedule", value: workflowScheduleTrigger(kind.value) };
+    case "event":
+      return { case: "event", value: workflowEventTriggerInvocation(kind.value) };
+    default:
+      return { case: undefined };
   }
-  return { value: current, ok: true };
 }
 
-function templateExpressionValue(
-  ctx: WorkflowEvalContext,
-  expr: string,
-): { value: unknown; ok: boolean } {
+function valueMapInput(input?: Record<string, JsonInput>): Record<string, JsonInput> {
+  return input === undefined ? {} : { ...input };
+}
+
+function latestWorkflowSignal(signals?: readonly WorkflowSignal[]): WorkflowSignal | undefined {
+  return signals === undefined || signals.length === 0 ? undefined : signals[signals.length - 1];
+}
+
+function templateExpressionValue(ctx: WorkflowEvalContext, expr: string): { value: unknown; ok: boolean } {
   if (expr.startsWith("inputs.")) {
-    if (!ctx.allowInputs) {
-      throw new WorkflowValueError("inputs references are not allowed here");
-    }
+    if (!ctx.allowInputs) throw new WorkflowValueError("inputs references are not allowed here");
     return mapPathValue(ctx.inputs, expr.slice("inputs.".length));
   }
-  if (expr.startsWith("runInput.")) {
-    return mapPathValue(ctx.request.input, expr.slice("runInput.".length));
-  }
-  if (expr.startsWith("signalPayload.")) {
+  if (expr.startsWith("input.")) return mapPathValue(ctx.request.input, expr.slice("input.".length));
+  if (expr.startsWith("signal.")) {
     const signal = latestWorkflowSignal(ctx.request.signals);
-    return signal === undefined
-      ? { value: undefined, ok: false }
-      : pathValue(signal.payload, expr.slice("signalPayload.".length));
+    return signal === undefined ? { value: undefined, ok: false } : pathValue(signal, expr.slice("signal.".length));
+  }
+  if (expr.startsWith("steps.")) {
+    return pathValue(ctx.request.steps ?? {}, expr.slice("steps.".length));
   }
   throw new WorkflowValueError(`unsupported template expression "${expr}"`);
 }
 
+function mapPathValue(value: unknown, path: string): { value: unknown; ok: boolean } {
+  return pathValue(value, path);
+}
+
 function renderTemplateValue(value: unknown): string {
   return typeof value === "string" ? value : JSON.stringify(value);
 }
 
 function pathSegments(path: string): Array<string | number> {
   const out: Array<string | number> = [];
-  for (let i = 0; i < path.length; ) {
+  for (let i = 0; i < path.length;) {
     if (path[i] === ".") {
       i += 1;
       continue;
@@ -3198,191 +1994,153 @@ function pathSegments(path: string): Array<string | number> {
     }
     const start = i;
     while (i < path.length && path[i] !== "." && path[i] !== "[") i += 1;
-    const key = path.slice(start, i).trim();
-    if (!key) throw new WorkflowValueError(`invalid workflow path "${path}"`);
-    out.push(key);
+    out.push(path.slice(start, i));
   }
-  return out;
+  return out.filter((segment) => segment !== "");
 }
 
 function parseBracketPathToken(token: string, path: string): string | number {
-  if (token.startsWith("'") || token.startsWith('"')) {
-    return unquotePathKey(token, path);
+  if (/^-?\d+$/.test(token)) return Number.parseInt(token, 10);
+  if ((token.startsWith("'") && token.endsWith("'")) || (token.startsWith("\"") && token.endsWith("\""))) {
+    return token.slice(1, -1).replace(/\\'/g, "'").replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
   }
-  const index = Number.parseInt(token, 10);
-  if (!/^[+-]?\d+$/.test(token) || !Number.isInteger(index)) {
-    throw new WorkflowValueError(`invalid workflow path "${path}"`);
-  }
-  return index;
+  throw new WorkflowValueError(`invalid workflow path "${path}"`);
 }
 
-function unquotePathKey(token: string, path: string): string {
-  if (token.startsWith('"')) {
-    try {
-      return JSON.parse(token);
-    } catch {
-      throw new WorkflowValueError(`invalid workflow path "${path}"`);
-    }
-  }
-  if (token.length < 2 || !token.endsWith("'")) {
-    throw new WorkflowValueError(`invalid workflow path "${path}"`);
-  }
-  let out = "";
-  for (let i = 1; i < token.length - 1;) {
-    const ch = token[i];
-    if (ch !== "\\") {
-      out += ch;
-      i += 1;
-      continue;
-    }
-    i += 1;
-    if (i >= token.length - 1) {
-      throw new WorkflowValueError(`invalid workflow path "${path}"`);
-    }
-    const escaped = token[i];
-    switch (escaped) {
-      case "'":
-      case '"':
-      case "\\":
-        out += escaped;
-        i += 1;
-        break;
-      case "n":
-        out += "\n";
-        i += 1;
-        break;
-      case "r":
-        out += "\r";
-        i += 1;
-        break;
-      case "t":
-        out += "\t";
-        i += 1;
-        break;
-      case "u": {
-        const hex = token.slice(i + 1, i + 5);
-        if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
-          throw new WorkflowValueError(`invalid workflow path "${path}"`);
-        }
-        out += String.fromCharCode(Number.parseInt(hex, 16));
-        i += 5;
-        break;
+function workflowTargetContext(target?: BoundWorkflowTarget): Record<string, JsonInput> | undefined {
+  if (target === undefined) return undefined;
+  return {
+    kind: "steps",
+    steps: (target.steps ?? []).map((step) => {
+      const app = step.app ?? (step.action?.case === "app" ? step.action.value : undefined);
+      const agent = step.agent ?? (step.action?.case === "agent" ? step.action.value : undefined);
+      if (app !== undefined) {
+        return {
+          id: step.id ?? "",
+          kind: "app",
+          app: app.name ?? "",
+          operation: app.operation ?? "",
+          credentialMode: app.credentialMode ?? "",
+        };
       }
-      default:
-        out += escaped;
-        i += 1;
-        break;
-    }
-  }
-  return out;
+      return {
+        id: step.id ?? "",
+        kind: "agent",
+        provider: agent?.provider ?? "",
+        model: agent?.model ?? "",
+      };
+    }),
+  };
 }
 
-function compactWorkflowSignalPayload(payload: JsonInput): Record<string, JsonInput> {
-  const source = workflowMapValue(payload);
-  if (Object.keys(source).length === 0) return {};
-  const out: Record<string, JsonInput> = {};
-  for (const key of [
-    "delivery_id", "deliveryId", "github_event", "githubEvent", "github_action", "githubAction",
-    "event", "action", "summary", "user_prompt", "userPrompt", "payload_sha256", "payloadSha256",
-    "payload_omitted", "payloadOmitted",
-  ]) {
-    copyCompactPayloadField(out, source, key);
-  }
-  for (const key of [
-    "agent_request", "agentRequest", "installation", "repository", "sender", "webhook_policy",
-    "webhookPolicy", "pull_request", "pullRequest", "issue", "comment", "review", "ref",
-    "check_run", "checkRun", "check_suite", "checkSuite", "workflow_run", "workflowRun",
-    "review_check_run", "reviewCheckRun",
-  ]) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const value = source[key];
-      if (value !== undefined) out[key] = compactJsonValue(value, 4);
-    }
-  }
-  const fields: Record<string, JsonInput> = {};
-  for (const key of Object.keys(source).sort()) {
-    if (Object.keys(fields).length >= 20) break;
-    if (Object.prototype.hasOwnProperty.call(out, key) || workflowSignalPayloadKeyExcluded(key)) {
-      continue;
-    }
-    const value = source[key];
-    if (value === undefined) continue;
-    const compact = compactJsonScalar(value);
-    if (compact.ok) fields[key] = compact.value;
+function workflowTriggerContext(trigger?: WorkflowRunTrigger): WorkflowRunContextTrigger {
+  const normalized = workflowRunTrigger(trigger);
+  switch (normalized.kind?.case) {
+    case "schedule":
+      return {
+        kind: "schedule",
+        activationId: normalized.kind.value.activationId ?? "",
+        scheduledFor: normalized.kind.value.scheduledFor?.toISOString() ?? "",
+      };
+    case "event":
+      return {
+        kind: "event",
+        activationId: normalized.kind.value.activationId ?? "",
+        scheduledFor: "",
+        event: workflowEventContext(normalized.kind.value.event),
+      };
+    case "manual":
+      return { kind: "manual", activationId: "", scheduledFor: "" };
+    default:
+      return { kind: "", activationId: "", scheduledFor: "" };
   }
-  if (Object.keys(fields).length > 0) out.fields = fields;
-  out.payloadOmitted = true;
-  return out;
 }
 
-function workflowMapValue(value: JsonInput): Record<string, JsonInput> {
-  return value !== null && typeof value === "object" && !Array.isArray(value)
-    ? { ...(value as Record<string, JsonInput>) }
-    : { value };
+function workflowEventContext(event?: WorkflowEvent): Record<string, JsonInput> | undefined {
+  if (event === undefined) return undefined;
+  return {
+    id: event.id ?? "",
+    source: event.source ?? "",
+    specVersion: event.specVersion ?? "",
+    type: event.type ?? "",
+    subject: event.subject ?? "",
+    datacontenttype: event.datacontenttype ?? "",
+    data: valueMapInput(event.data as Record<string, JsonInput> | undefined),
+  };
 }
 
-function copyCompactPayloadField(
-  out: Record<string, JsonInput>,
-  payload: Record<string, JsonInput>,
-  key: string,
-): void {
-  if (!Object.prototype.hasOwnProperty.call(payload, key) || workflowSignalPayloadKeyExcluded(key)) {
-    return;
-  }
-  const value = payload[key];
-  if (value === undefined) return;
-  const compact = compactJsonScalar(value);
-  out[key] = compact.ok ? compact.value : compactJsonValue(value, 4);
+function workflowRunContextData(value: unknown): Record<string, unknown> {
+  const root = workflowContextOptionalObject(value);
+  const workflow = workflowContextOptionalObject(root?.workflow);
+  return workflow ?? root ?? {};
 }
 
-function workflowSignalPayloadKeyExcluded(key: string): boolean {
-  return key.trim() === "" || key === "payload" || key === "_gestalt_payload_preview_json";
-}
-
-function compactJsonScalar(value: JsonInput): { value: JsonInput; ok: boolean } {
-  if (
-    value === null ||
-    typeof value === "string" ||
-    typeof value === "boolean" ||
-    typeof value === "number"
-  ) {
-    return {
-      value: typeof value === "string" ? truncateWorkflowString(value, 4096) : value,
-      ok: true,
-    };
-  }
-  return { value: null, ok: false };
-}
-
-function compactJsonValue(value: JsonInput, depth: number): JsonInput {
-  const scalar = compactJsonScalar(value);
-  if (scalar.ok) return scalar.value;
-  if (depth <= 0) return { omitted: true };
-  if (Array.isArray(value)) return value.slice(0, 20).map((item) => compactJsonValue(item, depth - 1));
-  const objectValue = value as Record<string, JsonInput>;
-  const keys = Object.keys(objectValue)
-    .filter((key) => !workflowSignalPayloadKeyExcluded(key))
-    .sort();
+function workflowRunContextTrigger(value: unknown): WorkflowRunContextTrigger {
+  const data = workflowContextOptionalObject(value) ?? {};
+  const event = workflowContextOptionalObject(data.event);
+  return {
+    kind: workflowContextString(data.kind),
+    activationId: workflowContextString(data.activationId),
+    scheduledFor: workflowContextString(data.scheduledFor),
+    event: event === undefined ? undefined : event as Record<string, JsonInput>,
+  };
+}
+
+function workflowRunContextSignal(value: unknown): WorkflowRunContextSignal | undefined {
+  if (value === null || typeof value !== "object") return undefined;
+  const record = value as Record<string, unknown>;
+  const sequence = workflowContextNumber(record.sequence);
+  return {
+    id: workflowContextString(record.id),
+    name: workflowContextString(record.name),
+    payload: workflowContextObject(record.payload),
+    metadata: workflowContextObject(record.metadata),
+    createdBySubjectId: workflowContextString(record.createdBySubjectId),
+    createdAt: workflowContextString(record.createdAt),
+    idempotencyKey: workflowContextString(record.idempotencyKey),
+    sequence,
+  };
+}
+
+function workflowContextString(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function workflowContextNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function workflowContextObject(value: unknown): Record<string, JsonInput> {
+  return workflowContextOptionalObject(value) ?? {};
+}
+
+function workflowContextOptionalObject(value: unknown): Record<string, JsonInput> | undefined {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return value as Record<string, JsonInput>;
+}
+
+function compactWorkflowSignalPayload(payload: JsonObjectInput): Record<string, JsonInput> {
+  const source = payload as Record<string, JsonInput>;
   const out: Record<string, JsonInput> = {};
-  for (const key of keys.slice(0, 20)) {
-    const item = objectValue[key];
-    if (item !== undefined) out[key] = compactJsonValue(item, depth - 1);
-  }
-  if (keys.length > Object.keys(out).length) {
-    out.omittedFields = keys.length - Object.keys(out).length;
+  const fields: Record<string, JsonInput> = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (workflowSignalPayloadKeyExcluded(key)) {
+      if (key === "payload") {
+        out.payloadOmitted = true;
+      } else {
+        out[key] = value;
+      }
+    } else {
+      fields[key] = value;
+    }
   }
+  if (Object.keys(fields).length > 0) out.fields = fields;
   return out;
 }
 
-function truncateWorkflowString(value: string, maxBytes: number): string {
-  const encoded = new TextEncoder().encode(value);
-  if (encoded.length <= maxBytes) return value;
-  const suffix = "...";
-  let bytes = encoded.slice(0, Math.max(0, maxBytes - suffix.length));
-  let text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
-  while (new TextEncoder().encode(text + suffix).length > maxBytes && text.length > 0) {
-    text = text.slice(0, -1);
-    bytes = new TextEncoder().encode(text);
-  }
-  return new TextDecoder().decode(bytes) + suffix;
+function workflowSignalPayloadKeyExcluded(key: string): boolean {
+  return [
+    "delivery_id", "deliveryId", "payload", "raw", "github", "github_event", "githubEvent",
+    "check_run", "checkRun", "check_suite", "checkSuite", "workflow_run", "workflowRun",
+  ].includes(key);
 }