temporal

type AccountModelRequestInput struct {
	SessionID      string            `json:"session_id"`
	ThreadID       string            `json:"thread_id,omitempty"`
	RequestEventID string            `json:"request_event_id"`
	Model          domain.Model      `json:"model"`
	Usage          domain.TokenUsage `json:"usage"`
	StopReason     string            `json:"stop_reason,omitempty"`
}

type Activities struct {
	// contains filtered or unexported fields
}

type AdmitModelRequestInput struct {
	SessionID string `json:"session_id"`
	ThreadID  string `json:"thread_id,omitempty"`
}

type AdmitModelRequestResult struct {
	Allowed bool `json:"allowed"`
}

type AdvisorToolSource interface {
	CompleteAdvisorToolStep(
		context.Context,
		string,
		string,
		string,
		string,
		domain.ToolStepResult,
		domain.AdvisorConsultation,
	) error
}

type AppendWorkflowEventsInput struct {
	SessionID      string              `json:"session_id"`
	TriggerEventID string              `json:"trigger_event_id"`
	Events         []domain.EventDraft `json:"events"`
}

type CallModelInput struct {
	SessionID           string `json:"session_id"`
	ThreadID            string `json:"thread_id,omitempty"`
	ModelRequestStartID string `json:"model_request_start_id,omitempty"`
	ModelRequestEndID   string `json:"model_request_end_id,omitempty"`
	// HandleRetryableErrors opts new Workflow histories into the public retry
	// lifecycle. Older histories leave it false and retain Activity-level retry
	// behavior, which keeps replay compatible across the rollout.
	HandleRetryableErrors bool          `json:"handle_retryable_errors,omitempty"`
	Request               model.Request `json:"request"`
}

type CallModelResult struct {
	Response             model.Response    `json:"response"`
	MessageEventID       string            `json:"message_event_id,omitempty"`
	ThinkingEventID      string            `json:"thinking_event_id,omitempty"`
	ModelRequestStartID  string            `json:"model_request_start_id,omitempty"`
	ModelRequestEndID    string            `json:"model_request_end_id,omitempty"`
	ToolSteps            []PlannedToolStep `json:"tool_steps,omitempty"`
	FatalError           string            `json:"fatal_error,omitempty"`
	FatalErrorType       string            `json:"fatal_error_type,omitempty"`
	ContextOverflow      bool              `json:"context_overflow,omitempty"`
	ContextOverflowError string            `json:"context_overflow_error,omitempty"`
	RetryError           *ModelRetryError  `json:"retry_error,omitempty"`
}

type ClientConfig struct {
	HostPort  string
	Namespace string
}

type CompleteWorkflowTurnInput struct {
	SessionID      string                 `json:"session_id"`
	ThreadID       string                 `json:"thread_id,omitempty"`
	IsChild        bool                   `json:"is_child,omitempty"`
	TriggerEventID string                 `json:"trigger_event_id"`
	Output         []domain.EventDraft    `json:"output"`
	Status         domain.Status          `json:"status"`
	AttemptID      string                 `json:"attempt_id,omitempty"`
	AttemptState   domain.RunAttemptState `json:"attempt_state,omitempty"`
	AttemptError   *string                `json:"attempt_error,omitempty"`
	// PendingActionEventIDs names action events in Output that park this turn
	// awaiting client input.
	PendingActionEventIDs []string `json:"pending_action_event_ids,omitempty"`
	// ResolutionEventIDs names every client event that closes the current
	// pending-action barrier. PostgreSQL validates the set atomically.
	ResolutionEventIDs []string `json:"resolution_event_ids,omitempty"`
	// TranscriptDelta and ToolUseMappings are provider-private continuation
	// state. PostgreSQL commits them atomically with Output when supported.
	TranscriptDelta       []domain.Message                `json:"transcript_delta,omitempty"`
	ToolUseMappings       []domain.ProviderToolUseMapping `json:"tool_use_mappings,omitempty"`
	Usage                 domain.TokenUsage               `json:"usage,omitempty"`
	UsageAlreadyAccounted bool                            `json:"usage_already_accounted,omitempty"`
}

type CoordinatorToolSource interface {
	ExecuteCoordinatorToolStep(
		context.Context, string, string, string, string, string, map[string]any,
	) (domain.ToolStepResult, error)
}

type DeletionStore interface {
	ListDeletingSessionIDs(ctx context.Context, limit int) ([]string, error)
	FinalizeSessionMemoryResources(ctx context.Context, sessionID string) error
	FinalizeSessionDeletion(ctx context.Context, sessionID string) error
}

type EnsureToolPermissionAttemptResult struct {
	Established bool `json:"established"`
}

type EvaluateOutcomeInput struct {
	SessionID    string             `json:"session_id"`
	StartEventID string             `json:"start_event_id,omitempty"`
	EndEventID   string             `json:"end_event_id,omitempty"`
	Model        string             `json:"model"`
	Effort       string             `json:"effort,omitempty"`
	Speed        string             `json:"speed,omitempty"`
	Outcome      domain.OutcomeSpec `json:"outcome"`
	Candidate    []domain.Message   `json:"candidate"`
	Iteration    int                `json:"iteration"`
	FinalCycle   bool               `json:"final_cycle"`
}

type EvaluateOutcomeResult struct {
	StartEventID string            `json:"start_event_id"`
	EndEventID   string            `json:"end_event_id"`
	Result       string            `json:"result"`
	Explanation  string            `json:"explanation"`
	Usage        domain.TokenUsage `json:"usage"`
	StopReason   string            `json:"stop_reason,omitempty"`
	FatalError   string            `json:"fatal_error,omitempty"`
}

type EvaluateToolPermissionInput struct {
	Owner          domain.ToolPermissionOwner `json:"owner"`
	ToolUseEventID string                     `json:"tool_use_event_id"`
	Model          domain.Model               `json:"model"`
	Input          permission.Input           `json:"input"`
}

type EvaluateToolPermissionResult struct {
	Decision     domain.ToolPermissionDecision `json:"decision"`
	BudgetPaused bool                          `json:"budget_paused"`
	Stopped      bool                          `json:"stopped"`
}

type EventRef struct {
	ID   string `json:"id"`
	Seq  int64  `json:"seq"`
	Type string `json:"type"`
}

type EventSource interface {
	EventsAfter(ctx context.Context, sessionID string, cursor int64, limit int) ([]domain.Event, error)
	FirstUnprocessedInterruptAfter(
		ctx context.Context,
		sessionID string,
		afterSeq int64,
	) (*domain.Event, error)
	HistoryThrough(ctx context.Context, sessionID, triggerEventID string, limit int) ([]domain.Event, error)
	GetSession(ctx context.Context, id string) (domain.Session, error)
	GetEvent(ctx context.Context, sessionID, id string) (domain.Event, error)
	UnresolvedPendingActions(ctx context.Context, sessionID string) ([]domain.PendingAction, error)
	CompleteWorkflowTurn(
		ctx context.Context,
		sessionID string,
		triggerEventID string,
		output []domain.EventDraft,
		status domain.Status,
		attemptID string,
		attemptState domain.RunAttemptState,
		attemptError *string,
		pendingActionEventIDs []string,
		resolutionEventIDs []string,
	) (TurnCompletionResult, error)
}

type ExecuteToolInput struct {
	SessionID           string                     `json:"session_id"`
	ThreadID            string                     `json:"thread_id,omitempty"`
	TriggerEventID      string                     `json:"trigger_event_id"`
	AttemptID           string                     `json:"attempt_id"`
	Ordinal             int                        `json:"ordinal"`
	ToolUseEventID      string                     `json:"tool_use_event_id"`
	ToolStepID          string                     `json:"tool_step_id"`
	ToolName            string                     `json:"tool_name"`
	PermissionReceiptID string                     `json:"permission_receipt_id,omitempty"`
	ToolKind            TurnToolKind               `json:"tool_kind,omitempty"`
	MCPServer           domain.MCPServer           `json:"mcp_server,omitempty"`
	MCPToolName         string                     `json:"mcp_tool_name,omitempty"`
	Input               map[string]any             `json:"input"`
	SkillRuntimeRoot    string                     `json:"skill_runtime_root,omitempty"`
	SkillAlreadyLoaded  bool                       `json:"skill_already_loaded,omitempty"`
	AdvisorRequest      model.Request              `json:"advisor_request,omitempty"`
	AdvisorConsultation domain.AdvisorConsultation `json:"advisor_consultation,omitempty"`
}

type ExecuteToolResult struct {
	Result     domain.ToolStepResult `json:"result"`
	Events     []domain.EventDraft   `json:"events,omitempty"`
	Ambiguous  bool                  `json:"ambiguous"`
	FatalError string                `json:"fatal_error,omitempty"`
}

type JournalStore interface {
	EnsureAttempt(ctx context.Context, sessionID, triggerEventID, attemptID string) error
	EnsureToolStep(ctx context.Context, attemptID, stepID string, ordinal int, toolUseEventID, toolName string, input map[string]any) (domain.ToolStep, error)
	StartToolStep(ctx context.Context, stepID string) error
	CompleteToolStep(ctx context.Context, stepID string, result domain.ToolStepResult) error
	MarkToolStepAmbiguous(ctx context.Context, stepID string) error
}

type LifecycleReconcileResult struct {
	Deletions int
}

type LifecycleReconciler struct {
	// contains filtered or unexported fields
}

type LifecycleReconcilerConfig struct {
	// PollInterval is the idle delay between scans. A scan that completes work
	// immediately repeats so a backlog drains without one interval per batch.
	PollInterval time.Duration
	// BatchSize bounds deleting-session scans.
	BatchSize int
	// AttemptTimeout prevents one unavailable provider from starving the rest of
	// the batch. The deterministic cleanup Workflow continues after this local
	// wait expires and a later scan joins it.
	AttemptTimeout time.Duration
}

type LoadEventsInput struct {
	SessionID string `json:"session_id"`
	ThreadID  string `json:"thread_id,omitempty"`
	Cursor    int64  `json:"cursor"`
	Limit     int    `json:"limit"`
}

type LoadEventsResult struct {
	Events []EventRef `json:"events"`
}

type LoadInterruptInput struct {
	SessionID string `json:"session_id"`
	ThreadID  string `json:"thread_id,omitempty"`
	AfterSeq  int64  `json:"after_seq"`
}

type LoadInterruptResult struct {
	Interrupt *EventRef `json:"interrupt,omitempty"`
}

type LoadPendingActionsInput struct {
	SessionID string `json:"session_id"`
	ThreadID  string `json:"thread_id,omitempty"`
}

type LoadPendingActionsResult struct {
	Actions []PendingActionRef `json:"actions,omitempty"`
}

type MCPDiscoveryStore interface {
	GetMCPDiscoverySnapshot(
		ctx context.Context,
		sessionID string,
		threadID string,
		server domain.MCPServer,
	) ([]mcpclient.Tool, bool, error)
	PutMCPDiscoverySnapshot(
		ctx context.Context,
		sessionID string,
		threadID string,
		server domain.MCPServer,
		tools []mcpclient.Tool,
	) ([]mcpclient.Tool, error)
}

type ModelRequestAdmissionSource interface {
	AdmitModelRequest(context.Context, string, string) (bool, error)
}

type ModelRequestUsageSource interface {
	AccountModelRequest(
		context.Context,
		string,
		string,
		string,
		domain.Model,
		domain.TokenUsage,
		string,
	) error
}

type ModelRetryError struct {
	Type             string `json:"type"`
	Message          string `json:"message"`
	RetryAfterMillis int64  `json:"retry_after_millis,omitempty"`
}

type Orchestrator struct {
	// contains filtered or unexported fields
}

type OutboxStore interface {
	ListWakeupsForDelivery(ctx context.Context, limit int) ([]pg.OutboxWakeup, error)
	DeleteWakeupIfUnchanged(ctx context.Context, sessionID string, maxSeq int64) (bool, error)
	RecordAttempt(ctx context.Context, sessionID string, cause string) error
}

type PendingActionRef struct {
	ActionEventID      string                   `json:"action_event_id"`
	ActionEventSeq     int64                    `json:"action_event_seq"`
	Kind               domain.PendingActionKind `json:"kind"`
	ResolutionEventID  string                   `json:"resolution_event_id,omitempty"`
	ResolutionEventSeq int64                    `json:"resolution_event_seq,omitempty"`
}

type PermissionSource interface {
	EnsureToolPermissionAttempt(context.Context, domain.ToolPermissionOwner) error
	PermissionIntentThrough(context.Context, string, string) (domain.PermissionIntent, error)
	GetToolPermissionReceipt(context.Context, domain.ToolPermissionReceipt) (*domain.ToolPermissionReceipt, error)
	AdmitToolPermissionEvaluation(context.Context, domain.ToolPermissionReceipt) (bool, error)
	RecordToolPermissionReceipt(context.Context, domain.ToolPermissionReceipt) (domain.ToolPermissionReceipt, error)
	StartToolStepWithPermission(context.Context, string, string) error
}

type PlannedToolStep struct {
	ToolUseEventID    string `json:"tool_use_event_id"`
	ProviderToolUseID string `json:"provider_tool_use_id"`
	ToolStepID        string `json:"tool_step_id"`
}

type PrepareTurnInput struct {
	SessionID          string   `json:"session_id"`
	TriggerEventID     string   `json:"trigger_event_id"`
	ResolutionEventIDs []string `json:"resolution_event_ids,omitempty"`
}

type PrepareTurnResult struct {
	AlreadyCompleted bool           `json:"already_completed"`
	Terminated       bool           `json:"terminated"`
	FatalError       string         `json:"fatal_error,omitempty"`
	AttemptID        string         `json:"attempt_id,omitempty"`
	ThreadID         string         `json:"thread_id,omitempty"`
	IsChild          bool           `json:"is_child,omitempty"`
	SkillRuntimeRoot string         `json:"skill_runtime_root,omitempty"`
	Request          model.Request  `json:"request"`
	Tools            []TurnTool     `json:"tools,omitempty"`
	ResumeActions    []ResumeAction `json:"resume_actions,omitempty"`
	// PreludeEvents are recoverable setup diagnostics, such as one unavailable
	// MCP server. The Workflow commits them with the turn while continuing with
	// the remaining tool surface.
	PermissionIntent domain.PermissionIntent `json:"permission_intent"`
	PreludeEvents    []domain.EventDraft     `json:"prelude_events,omitempty"`
	// UsesProviderTranscript is true when Request.Messages came from the
	// lossless private transcript rather than the legacy public-event
	// projection. TranscriptDelta contains only the new input represented by
	// this turn; Workflow code appends provider responses and tool results.
	UsesProviderTranscript bool                     `json:"uses_provider_transcript,omitempty"`
	TranscriptDelta        []domain.Message         `json:"transcript_delta,omitempty"`
	Outcome                *domain.OutcomeSpec      `json:"outcome,omitempty"`
	ContextProjection      domain.ContextProjection `json:"context_projection"`
	ContextSnapshotID      string                   `json:"context_snapshot_id,omitempty"`
}

type PreviewPublisher interface {
	PublishPreview(context.Context, string, domain.PreviewFrame) error
}

type ProviderTranscriptCompletionSource interface {
	CompleteWorkflowTurnWithTranscript(
		ctx context.Context,
		sessionID string,
		triggerEventID string,
		output []domain.EventDraft,
		status domain.Status,
		attemptID string,
		attemptState domain.RunAttemptState,
		attemptError *string,
		pendingActionEventIDs []string,
		resolutionEventIDs []string,
		transcriptDelta []domain.Message,
		toolUseMappings []domain.ProviderToolUseMapping,
	) (TurnCompletionResult, error)
}

type ProviderTranscriptSource interface {
	LoadProviderTranscript(
		ctx context.Context,
		sessionID string,
	) (domain.ProviderTranscript, error)
}

type ProviderTranscriptUsageCompletionSource interface {
	CompleteWorkflowTurnWithTranscriptAndUsage(
		ctx context.Context,
		sessionID string,
		triggerEventID string,
		output []domain.EventDraft,
		status domain.Status,
		attemptID string,
		attemptState domain.RunAttemptState,
		attemptError *string,
		pendingActionEventIDs []string,
		resolutionEventIDs []string,
		transcriptDelta []domain.Message,
		toolUseMappings []domain.ProviderToolUseMapping,
		usage domain.TokenUsage,
	) (TurnCompletionResult, error)
}

type RecordModelRetryInput struct {
	SessionID      string          `json:"session_id"`
	ThreadID       string          `json:"thread_id,omitempty"`
	IsChild        bool            `json:"is_child,omitempty"`
	TriggerEventID string          `json:"trigger_event_id"`
	ErrorEventID   string          `json:"error_event_id"`
	StatusEventID  string          `json:"status_event_id"`
	Error          ModelRetryError `json:"error"`
}

type Relay struct {
	// contains filtered or unexported fields
}

type RelayConfig struct {
	// PollInterval is how often the relay scans the outbox when the last scan
	// found no pending wakeups.
	PollInterval time.Duration
	// BatchSize bounds how many wakeups one scan reads.
	BatchSize int
}

type ResumeAction struct {
	ActionEventID string `json:"action_event_id"`
	// ActionEventType is the public event type PostgreSQL durably holds for the
	// parked call. The result that answers this action must be the matching
	// documented variant, and that decision cannot be made from Workflow code
	// alone: a barrier can outlive both a worker upgrade and a Continue-As-New,
	// so the answering execution may run newer code than the one that wrote the
	// call. An empty value predates this field and means the legacy
	// agent.tool_use spelling.
	ActionEventType     string                   `json:"action_event_type,omitempty"`
	EvaluatedPermission string                   `json:"evaluated_permission,omitempty"`
	Kind                domain.PendingActionKind `json:"kind"`
	ToolName            string                   `json:"tool_name"`
	Input               map[string]any           `json:"input"`
	ResolutionEventID   string                   `json:"resolution_event_id"`
	Content             []any                    `json:"content,omitempty"`
	IsError             bool                     `json:"is_error,omitempty"`
	Confirmation        string                   `json:"confirmation,omitempty"`
	DenyMessage         string                   `json:"deny_message,omitempty"`
	ToolStepID          string                   `json:"tool_step_id,omitempty"`
	ProviderToolUseID   string                   `json:"provider_tool_use_id,omitempty"`
}

type ResumeModelRetryInput struct {
	SessionID      string `json:"session_id"`
	ThreadID       string `json:"thread_id,omitempty"`
	IsChild        bool   `json:"is_child,omitempty"`
	TriggerEventID string `json:"trigger_event_id"`
	StatusEventID  string `json:"status_event_id"`
}

type RunTurnResult struct {
	Disposition TurnDisposition `json:"disposition"`
}

type Runtime struct {
	Client    client.Client
	Worker    worker.Worker
	Relay     *Relay
	Lifecycle *LifecycleReconciler
	Store     *pg.Store
	Signal    *Signaler
}

type RuntimeConfig struct {
	TemporalClient client.Client
	Store          *pg.Store
	ModelClient    model.Client
	// PermissionEvaluator defaults to the configured model adapter.
	PermissionEvaluator permission.Evaluator
	IDGenerator         domain.IDGenerator
	RelayConfig         RelayConfig
	TaskQueue           string
	SkillInstructions   SkillInstructionLoader
	ToolOutputs         ToolOutputStore
	MCPAuth             credentialruntime.AuthSource
	PreviewPublisher    PreviewPublisher
}

type SessionSkillSource interface {
	SessionSkillsForRuntime(context.Context, string) ([]domain.SkillVersion, error)
}

type SessionTerminator interface {
	TerminateSession(ctx context.Context, sessionID string) error
}

type SessionThreadSkillSource interface {
	SessionThreadSkillRuntime(
		context.Context,
		string,
		string,
	) (domain.SkillRuntime, error)
}

type SessionThreadSource interface {
	GetSessionThread(context.Context, string, string) (domain.SessionThread, error)
}

type SessionThreadWorkflowInput struct {
	SessionID   string `json:"session_id"`
	ThreadID    string `json:"thread_id"`
	StartCursor int64  `json:"start_cursor"`
}

type SessionWorkflowInput struct {
	SessionID   string `json:"session_id"`
	StartCursor int64  `json:"start_cursor"`
}

type Signaler struct {
	// contains filtered or unexported fields
}

type SkillInstructionLoader interface {
	LoadSkillInstructions(context.Context, domain.SkillVersion) ([]byte, error)
}

type StartModelRequestInput struct {
	SessionID           string `json:"session_id"`
	TriggerEventID      string `json:"trigger_event_id"`
	ModelRequestStartID string `json:"model_request_start_id"`
}

type ThreadCompletionSource interface {
	CompleteThreadWorkflowTurn(
		ctx context.Context,
		sessionID string,
		threadID string,
		triggerEventID string,
		output []domain.EventDraft,
		status domain.Status,
		attemptID string,
		attemptState domain.RunAttemptState,
		attemptError *string,
		pendingActionEventIDs []string,
		resolutionEventIDs []string,
		transcriptDelta []domain.Message,
		toolUseMappings []domain.ProviderToolUseMapping,
		usage domain.TokenUsage,
	) (TurnCompletionResult, error)
}

type ThreadContextSnapshotSource interface {
	GetThreadContextSnapshotForTrigger(
		ctx context.Context,
		sessionID string,
		threadID string,
		triggerEventID string,
	) (domain.ContextSnapshot, bool, error)
	PutThreadContextSnapshot(
		ctx context.Context,
		sessionID string,
		threadID string,
		triggerEventID string,
		transcriptTriggerEventIDs []string,
		messages []domain.Message,
		projection domain.ContextProjection,
	) (domain.ContextSnapshot, error)
}

type ThreadEventSource interface {
	ThreadEventsAfter(
		context.Context, string, string, int64, int,
	) ([]domain.Event, error)
}

type ThreadInterruptSource interface {
	FirstUnprocessedThreadInterruptAfter(
		ctx context.Context,
		sessionID string,
		threadID string,
		afterSeq int64,
	) (*domain.Event, error)
}

type ThreadOutboxStore interface {
	DeleteThreadWakeupIfUnchanged(
		ctx context.Context, sessionID string, threadID string, maxSeq int64,
		intent pg.OrchestrationIntent,
	) (bool, error)
	RecordThreadAttempt(
		ctx context.Context, sessionID string, threadID string, cause string,
	) error
}

type ThreadPendingActionSource interface {
	UnresolvedThreadPendingActions(
		context.Context, string, string,
	) ([]domain.PendingAction, error)
}

type ThreadProviderTranscriptSource interface {
	LoadThreadProviderTranscript(
		ctx context.Context,
		sessionID string,
		threadID string,
	) (domain.ProviderTranscript, error)
}

type ThreadTerminationDeliverer interface {
	TerminateThread(ctx context.Context, sessionID string, threadID string) error
}

type ThreadWakeupDeliverer interface {
	WakeThread(
		ctx context.Context, sessionID string, threadID string, maxEventSeq int64,
	) error
}

type ThreadWorkflowRetrySource interface {
	RecordThreadWorkflowRetry(
		context.Context, string, string, string, string, string, map[string]any,
	) error
	ResumeThreadWorkflowRetry(
		context.Context, string, string, string, string,
	) error
}

type ToolOutputStore interface {
	StoreToolOutput(context.Context, string, string, string) error
}

type TurnCompletionResult struct {
	Events  []domain.Event
	Applied bool
	Status  domain.Status
	// Parked is a pointer for Workflow-history compatibility. Activity results
	// recorded before durable interrupt support have no field; nil tells
	// CompleteWorkflowTurn to use the legacy input-derived disposition. New
	// results always carry an explicit true/false from PostgreSQL.
	Parked *bool
}

type TurnDisposition string

type TurnTool struct {
	Name        string                  `json:"name"`
	Kind        TurnToolKind            `json:"kind"`
	Permission  domain.PermissionPolicy `json:"permission"`
	MCPServer   domain.MCPServer        `json:"mcp_server,omitempty"`
	MCPToolName string                  `json:"mcp_tool_name,omitempty"`
	Model       string                  `json:"model,omitempty"`
}

type TurnToolKind string

type UsageCompletionSource interface {
	CompleteWorkflowTurnWithUsage(
		ctx context.Context,
		sessionID string,
		triggerEventID string,
		output []domain.EventDraft,
		status domain.Status,
		attemptID string,
		attemptState domain.RunAttemptState,
		attemptError *string,
		pendingActionEventIDs []string,
		resolutionEventIDs []string,
		usage domain.TokenUsage,
	) (TurnCompletionResult, error)
}

type WakeupDeliverer interface {
	Wake(ctx context.Context, sessionID string, maxEventSeq int64) error
}

type WakeupSignal struct {
	MaxEventSeq int64 `json:"max_event_seq"`
}

type WorkflowEventSource interface {
	AppendWorkflowEvents(
		ctx context.Context,
		sessionID string,
		triggerEventID string,
		drafts []domain.EventDraft,
	) error
}

type WorkflowRetrySource interface {
	RecordWorkflowRetry(
		ctx context.Context,
		sessionID string,
		triggerEventID string,
		errorEventID string,
		statusEventID string,
		errorPayload map[string]any,
	) error
	ResumeWorkflowRetry(
		ctx context.Context,
		sessionID string,
		triggerEventID string,
		statusEventID string,
	) error
}