@relayfx/sdk 0.7.10 → 0.7.11

package/dist/types/runtime/agent/agent-loop-events.d.ts

@@ -2,20 +2,21 @@ import type { AgentEvent, ModelTelemetry } from "@batonfx/core";
 import { Content, Execution, Shared, Tool } from "../../schema/index";
 import type { Response } from "effect/unstable/ai";
 import type { RunInput } from "./agent-loop-service";
+type ExecutionEventDraft = Omit<Execution.ExecutionEvent, "sequence">;
 declare const legacyTelemetryCursor: (input: RunInput, event: ModelTelemetry.Event) => string;
 declare const legacyUsageCursor: (input: RunInput, event: ModelTelemetry.ModelAttemptCompleted) => string;
-declare const telemetryEvent: (input: RunInput, sessionId: string, event: ModelTelemetry.Event, sequence: number, createdAt: number) => Execution.ExecutionEvent;
-declare const inputPreparedEvent: (input: RunInput, definitions: ReadonlyArray<Tool.Definition>) => Execution.ExecutionEvent;
-declare const usageReportedEvent: (input: RunInput, sessionId: string, event: ModelTelemetry.ModelAttemptCompleted, sequence: Execution.ExecutionEventSequence, createdAt: number) => Execution.ExecutionEvent;
-declare const budgetExceededEvent: (input: RunInput, tokensUsed: number, tokenBudget: number, sequence: Execution.ExecutionEventSequence) => Execution.ExecutionEvent;
-declare const outputDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.TextDeltaPart, deltaIndex: number, createdAt: number) => Execution.ExecutionEvent;
-declare const reasoningDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.ReasoningPart | Response.ReasoningDeltaPart, deltaIndex: number, createdAt: number) => Execution.ExecutionEvent;
-declare const toolCallDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.ToolParamsDeltaPart, toolCallName: string | undefined, sequence: Execution.ExecutionEventSequence, deltaIndex: number, createdAt: number) => Execution.ExecutionEvent;
-declare const outputCompletedEvent: (input: RunInput, content: ReadonlyArray<Content.Part>, outputText: string, sequence: Execution.ExecutionEventSequence, structuredOutput?: Shared.JsonValue, structuredIdentity?: {
+declare const telemetryEvent: (input: RunInput, sessionId: string, event: ModelTelemetry.Event, createdAt: number) => ExecutionEventDraft;
+declare const inputPreparedEvent: (input: RunInput, definitions: ReadonlyArray<Tool.Definition>) => ExecutionEventDraft;
+declare const usageReportedEvent: (input: RunInput, sessionId: string, event: ModelTelemetry.ModelAttemptCompleted, createdAt: number) => ExecutionEventDraft;
+declare const budgetExceededEvent: (input: RunInput, tokensUsed: number, tokenBudget: number) => ExecutionEventDraft;
+declare const outputDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.TextDeltaPart, deltaIndex: number, createdAt: number) => ExecutionEventDraft;
+declare const reasoningDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.ReasoningPart | Response.ReasoningDeltaPart, deltaIndex: number, createdAt: number) => ExecutionEventDraft;
+declare const toolCallDeltaEvent: (input: RunInput, modelPart: AgentEvent.ModelPart, part: Response.ToolParamsDeltaPart, toolCallName: string | undefined, deltaIndex: number, createdAt: number) => ExecutionEventDraft;
+declare const outputCompletedEvent: (input: RunInput, content: ReadonlyArray<Content.Part>, outputText: string, structuredOutput?: Shared.JsonValue, structuredIdentity?: {
     readonly modelCallId: string;
     readonly modelAttemptId: string;
     readonly attempt: number;
-}) => Execution.ExecutionEvent;
+}) => ExecutionEventDraft;
 declare const completedContent: (outputText: string) => ReadonlyArray<Content.Part>;
 declare const modelOutputMetadata: (event: Execution.ExecutionEvent) => Shared.Metadata;
 export declare const AgentLoopEvents: {

package/dist/types/runtime/agent/agent-loop-service.d.ts

@@ -32,6 +32,7 @@ export declare class AgentLoopWaitRequested extends AgentLoopWaitRequested_base
 }
 export interface RunInput {
     readonly executionId: Ids.ExecutionId;
+    readonly operationId: string;
     readonly origin?: Execution.ExecutionOrigin;
     readonly sessionId?: Ids.SessionId;
     readonly agent: Agent.Definition;

package/dist/types/runtime/agent/emission-ordinal-allocator.d.ts

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+/** Invocation-local deterministic emission ordinals. These are never durable event sequences. */
+export interface EmissionOrdinalAllocator {
+    readonly allocate: (count: number) => Effect.Effect<number>;
+    readonly current: Effect.Effect<number>;
+}
+export declare const make: Effect.Effect<EmissionOrdinalAllocator>;

package/dist/types/runtime/agent/relay-permissions.d.ts

@@ -1,21 +1,18 @@
 import { Approvals, Permissions } from "@batonfx/core";
 import { Agent, Execution, Ids } from "../../schema/index";
 import { PermissionRuleRepository } from "../../store-sql/portable";
-import { Effect, Layer } from "effect";
+import { Layer } from "effect";
 import type { Interface as EventLogInterface } from "../execution/event-log-service";
 import type { Interface as WaitServiceInterface } from "../wait/wait-service";
-export interface SequenceAllocator {
-    readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
-    readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
-    readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
-}
 export interface Config {
     readonly ruleset: Agent.PermissionRuleset;
     readonly repository: PermissionRuleRepository.Interface;
     readonly waits: WaitServiceInterface;
     readonly eventLog: EventLogInterface;
-    readonly allocator: SequenceAllocator;
     readonly executionId: Ids.ExecutionId;
+    readonly operationId: string;
+    readonly resumedPermissionWaitId?: Ids.WaitId;
+    readonly resumedPermissionToolCallId?: string;
     readonly agentName: string;
     readonly scope: string;
     readonly startedAt: number;

package/dist/types/runtime/agent/relay-steering.d.ts

@@ -1,17 +1,17 @@
 import { Steering } from "@batonfx/core";
-import { Execution, Ids } from "../../schema/index";
+import { Ids } from "../../schema/index";
 import { SteeringRepository } from "../../store-sql/portable";
 import { Effect, Layer } from "effect";
 import type { Interface } from "../execution/event-log-service";
-export interface SequenceAllocator {
-    readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
+export interface EmissionOrdinalAllocator {
+    readonly allocate: (count: number) => Effect.Effect<number>;
 }
 export interface Config {
     readonly repository: SteeringRepository.Interface;
     readonly eventLog: Interface;
-    readonly allocator: SequenceAllocator;
+    readonly allocator: EmissionOrdinalAllocator;
     readonly executionId: Ids.ExecutionId;
+    readonly operationId: string;
     readonly startedAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
 }
 export declare const layer: (config: Config) => Layer.Layer<Steering.Steering>;

package/dist/types/runtime/agent/relay-tool-executor.d.ts

@@ -7,10 +7,11 @@ export interface Config {
     readonly toolRuntime: ToolRuntimeInterface;
     readonly eventLog: EventLogInterface;
     readonly allocator: {
-        readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
-        readonly advanceTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
+        readonly allocate: (count: number) => Effect.Effect<number>;
     };
     readonly executionId: Ids.ExecutionId;
+    readonly operationId: string;
+    readonly resumedPermissionWaitId?: Ids.WaitId;
     readonly permissions: ReadonlyArray<Tool.Permission>;
     readonly startedAt: number;
     readonly eventSequence: Execution.ExecutionEventSequence;

package/dist/types/runtime/envelope/envelope-service.d.ts

@@ -35,7 +35,8 @@ export interface SendInput {
     readonly envelopeId: Ids.EnvelopeId;
     readonly executionId: Ids.ExecutionId;
     readonly input: Envelope.SendInput;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    /** @deprecated Event ordering is allocated transactionally by the event repository. */
+    readonly eventSequence?: Execution.ExecutionEventSequence;
     readonly createdAt: number;
     readonly waitId?: Ids.WaitId;
 }

package/dist/types/runtime/execution/event-log-service.d.ts

@@ -1,6 +1,7 @@
 import { Execution, Ids } from "../../schema/index";
 import { ExecutionEventRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
+export type ExecutionEventDraft = ExecutionEventRepository.ExecutionEventDraft;
 declare const EventLogCursorNotFound_base: Schema.Class<EventLogCursorNotFound, Schema.TaggedStruct<"EventLogCursorNotFound", {
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -74,15 +75,15 @@ export declare class Service extends Service_base {
 }
 export declare const layerFromRepository: Layer.Layer<Service, never, ExecutionEventRepository.Service>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
-type TestImplementation = Omit<Interface, "appendNext" | "page"> & Partial<Pick<Interface, "appendNext" | "page">>;
+type TestImplementation = Omit<Interface, "page"> & Partial<Pick<Interface, "page">>;
 export declare const testLayer: (implementation: TestImplementation) => Layer.Layer<Service, never, never>;
 export declare const appendIdempotentTo: {
-    (eventLog: Interface, input: Execution.ExecutionEvent): Effect.Effect<Execution.ExecutionEvent, EventLogError>;
-    (input: Execution.ExecutionEvent): (eventLog: Interface) => Effect.Effect<Execution.ExecutionEvent, EventLogError>;
+    (eventLog: Interface, input: ExecutionEventRepository.ExecutionEventDraft): Effect.Effect<Execution.ExecutionEvent, EventLogError>;
+    (input: ExecutionEventRepository.ExecutionEventDraft): (eventLog: Interface) => Effect.Effect<Execution.ExecutionEvent, EventLogError>;
 };
 export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
 export declare const appendNext: (input: ExecutionEventRepository.AppendNextInput) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
-export declare const appendIdempotent: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
+export declare const appendIdempotent: (input: ExecutionEventRepository.ExecutionEventDraft) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
 export declare const replay: (input: ReplayInput) => Effect.Effect<readonly Execution.ExecutionEvent[], EventLogCursorNotFound | EventLogError, Service>;
 export declare const page: (input: PageInput) => Effect.Effect<PageResult, EventLogCursorNotFound | EventLogError, Service>;
 export declare const findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;

package/dist/types/runtime/execution/execution-service.d.ts

@@ -41,7 +41,7 @@ export interface RunProgramResult {
 }
 export interface CancelInput {
     readonly executionId: Ids.ExecutionId;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly eventSequence?: Execution.ExecutionEventSequence;
     readonly cancelledAt: number;
     readonly reason?: string;
     readonly metadata?: Shared.Metadata;

package/dist/types/runtime/inbox/inbox-service.d.ts

@@ -1,7 +1,6 @@
 import { Content, Envelope, Execution, Ids, Inbox } from "../../schema/index";
-import { EnvelopeRepository, ExecutionRepository, InboxRepository } from "../../store-sql/portable";
+import { EnvelopeRepository, ExecutionEventRepository, ExecutionRepository, InboxRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
 import { Service as WaitService } from "../wait/wait-service";
 import type { ExecutionClientFactory } from "../wait/wait-signal";
 declare const InboxDeliveryError_base: Schema.Class<InboxDeliveryError, Schema.TaggedStruct<"InboxDeliveryError", {
@@ -28,7 +27,8 @@ export interface DeliverInput {
     readonly acceptance?: EnvelopeRepository.AcceptEnvelopeInput;
     readonly idempotencyKey?: string;
     readonly replyWaitId?: Ids.WaitId;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    /** @deprecated Durable event order is allocated by the execution event head. */
+    readonly eventSequence?: Execution.ExecutionEventSequence;
     readonly createdAt: number;
 }
 export interface DeliverResult {
@@ -64,9 +64,9 @@ export interface SignalDependencies {
     readonly makeExecutionClient: ExecutionClientFactory;
     readonly executionRepository: ExecutionRepository.Service["Service"];
 }
-export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | InboxRepository.Service | EventLogService | WaitService>;
-export declare const layerWithSignal: (dependencies: SignalDependencies) => Layer.Layer<Service, never, EnvelopeRepository.Service | InboxRepository.Service | EventLogService | WaitService>;
-export declare const memoryLayer: Layer.Layer<Service, never, EventLogService | WaitService>;
+export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | InboxRepository.Service | WaitService>;
+export declare const layerWithSignal: (dependencies: SignalDependencies) => Layer.Layer<Service, never, EnvelopeRepository.Service | InboxRepository.Service | WaitService>;
+export declare const memoryLayer: Layer.Layer<Service | InboxRepository.Service | ExecutionEventRepository.Service, never, WaitService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxDeliveryError, Service>;
 export declare const ensureReplyWait: (input: EnsureReplyWaitInput) => Effect.Effect<void, InboxDeliveryError, Service>;

package/dist/types/runtime/schedule/scheduler-service.d.ts

@@ -1,7 +1,6 @@
 import { Schedule } from "../../schema/index";
 import { ExecutionRepository, ScheduleRepository } from "../../store-sql/portable";
 import { Config, Context, Cron, Effect, Layer, Option, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
 import { Service as WaitServiceService } from "../wait/wait-service";
 declare const SchedulerError_base: Schema.Class<SchedulerError, Schema.TaggedStruct<"SchedulerError", {
     readonly message: Schema.String;
@@ -26,9 +25,9 @@ export declare const enabledConfig: Config.Config<boolean>;
 export declare const workerIdConfig: Config.Config<Option.Option<string>>;
 export declare const parseCron: (cronExpr: string) => Effect.Effect<Cron.Cron, ScheduleCronInvalid>;
 export declare const startIdempotencyKey: (schedule: Schedule.ScheduleRecord) => string;
-export declare const make: Effect.Effect<Interface, Config.ConfigError, ExecutionRepository.Service | ScheduleRepository.Service | EventLogService | WaitServiceService | import("effect/unstable/cluster/Sharding").Sharding>;
-export declare const layer: Layer.Layer<Service, Config.ConfigError, ExecutionRepository.Service | ScheduleRepository.Service | EventLogService | WaitServiceService | import("effect/unstable/cluster/Sharding").Sharding>;
-export declare const memoryLayer: Layer.Layer<Service, Config.ConfigError, ExecutionRepository.Service | ScheduleRepository.Service | EventLogService | WaitServiceService | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const make: Effect.Effect<Interface, Config.ConfigError, ExecutionRepository.Service | ScheduleRepository.Service | WaitServiceService | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const layer: Layer.Layer<Service, Config.ConfigError, ExecutionRepository.Service | ScheduleRepository.Service | WaitServiceService | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const memoryLayer: Layer.Layer<Service, Config.ConfigError, ExecutionRepository.Service | ScheduleRepository.Service | WaitServiceService | import("effect/unstable/cluster/Sharding").Sharding>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const runOnce: () => Effect.Effect<number, SchedulerError, Service>;
 export {};

package/dist/types/runtime/state/execution-state-service.d.ts

@@ -1,5 +1,5 @@
 import { Ids, Shared, State } from "../../schema/index";
-import { ExecutionStateRepository } from "../../store-sql/portable";
+import { ExecutionEventRepository, ExecutionRepository, ExecutionStateRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Service as BlobStoreService } from "../content/blob-store-service";
 export declare const StateVersionConflict: typeof ExecutionStateRepository.StateVersionConflict;
@@ -55,6 +55,6 @@ declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/stat
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, ExecutionStateRepository.Service | BlobStoreService>;
-export declare const memoryLayer: Layer.Layer<Service, never, BlobStoreService>;
+export declare const memoryLayer: Layer.Layer<Service | ExecutionStateRepository.Service | ExecutionRepository.Service | ExecutionEventRepository.Service, never, BlobStoreService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export {};

package/dist/types/runtime/tool/tool-runtime-contract.d.ts

@@ -100,6 +100,8 @@ export interface PlacedToolOptions {
 export type ToolkitRegistrationOptions = ToolkitToolOptions | ((tool: AiTool.Any) => ToolkitToolOptions);
 export interface RunInput {
     readonly executionId: Ids.ExecutionId;
+    readonly operationId: string;
+    readonly resumedPermissionWaitId?: Ids.WaitId;
     readonly call: Tool.Call;
     readonly permissions: ReadonlyArray<Tool.Permission>;
     readonly eventSequence: Execution.ExecutionEventSequence;

package/dist/types/runtime/tool/tool-runtime-identifiers.d.ts

@@ -2,8 +2,14 @@ import { Ids } from "../../schema/index";
 export type ToolWaitKind = "approval" | "permission" | "tool";
 declare const eventId: (executionId: Ids.ExecutionId, toolCallId: Ids.ToolCallId | string, kind: "tool-requested" | "tool-result" | "approval-requested" | "approval-resolved" | "permission-requested" | "permission-resolved") => string & import("effect/Brand").Brand<"Relay.EventId">;
 declare const waitId: (kind: ToolWaitKind, executionId: Ids.ExecutionId, toolCallId: Ids.ToolCallId | string) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+declare const permissionWaitId: (executionId: Ids.ExecutionId, operationId: string, toolCallId: Ids.ToolCallId | string) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+declare const permissionEventId: (executionId: Ids.ExecutionId, operationId: string, toolCallId: Ids.ToolCallId | string, kind: "requested" | "resolved") => string & import("effect/Brand").Brand<"Relay.EventId">;
+declare const permissionEventIdForWait: (permissionWait: Ids.WaitId | string, kind: "requested" | "resolved") => string & import("effect/Brand").Brand<"Relay.EventId">;
 export declare const Identifiers: {
     eventId: typeof eventId;
+    permissionEventId: typeof permissionEventId;
+    permissionEventIdForWait: typeof permissionEventIdForWait;
+    permissionWaitId: typeof permissionWaitId;
     waitId: typeof waitId;
 };
 export {};

package/dist/types/runtime/wait/wait-service.d.ts

@@ -24,7 +24,7 @@ export declare class WaitServiceError extends WaitServiceError_base {
 export interface CreateWaitInput {
     readonly waitId: Ids.WaitId;
     readonly envelope: Envelope.Envelope;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly eventSequence?: Execution.ExecutionEventSequence;
 }
 export interface CreateDetachedWaitInput {
     readonly waitId: Ids.WaitId;
@@ -33,25 +33,25 @@ export interface CreateDetachedWaitInput {
     readonly correlationKey?: string;
     readonly metadata?: Shared.Metadata;
     readonly timeout?: string;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly eventSequence?: Execution.ExecutionEventSequence;
     readonly createdAt: number;
 }
 export interface WakeInput {
     readonly waitId: Ids.WaitId;
     readonly resolvedAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly eventSequence?: Execution.ExecutionEventSequence;
     readonly metadata?: Shared.Metadata;
 }
 export interface TimeoutInput {
     readonly waitId: Ids.WaitId;
     readonly timedOutAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly eventSequence?: Execution.ExecutionEventSequence;
     readonly metadata?: Shared.Metadata;
 }
 export interface CancelWaitInput {
     readonly waitId: Ids.WaitId;
     readonly cancelledAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly eventSequence?: Execution.ExecutionEventSequence;
     readonly metadata?: Shared.Metadata;
 }
 export interface WaitTransition {

package/dist/types/runtime/workflow/execution-workflow.d.ts

@@ -6,7 +6,6 @@ import { Cause, Effect, Layer, Option, Schema } from "effect";
 import { AgentLoopBudgetExceeded, AgentLoopError } from "../agent/agent-loop-error";
 import { Service as AgentLoopService } from "../agent/agent-loop-service";
 import { ChildTerminalStatus } from "../child/parent-notifier-service";
-import { Service as EventLogService } from "../execution/event-log-service";
 import { Service as ToolRuntimeService } from "../tool/tool-runtime-service";
 import { Service as ToolTransitionCoordinatorService } from "../tool/tool-transition-coordinator";
 declare const ExecutionWorkflowFailed_base: Schema.Class<ExecutionWorkflowFailed, Schema.TaggedStruct<"ExecutionWorkflowFailed", {
@@ -523,7 +522,7 @@ export declare const sessionEntryScope: {
     (input: StartInput, turn: number): string;
     (turn: number): (input: StartInput) => string;
 };
-export declare const layer: Layer.Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | ToolRuntimeService | import("../address/address-resolution-service").Service | import("../skill/skill-registry-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | import("../workspace/workspace-planner-service").Service | AgentLoopService | WorkflowEngine.WorkflowEngine>;
+export declare const layer: Layer.Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | import("../wait/wait-service").Service | ToolRuntimeService | import("../address/address-resolution-service").Service | import("../skill/skill-registry-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | import("../workspace/workspace-planner-service").Service | AgentLoopService | WorkflowEngine.WorkflowEngine>;
 interface StartOptions<Discard extends boolean> {
     readonly discard?: Discard;
 }
@@ -536,7 +535,7 @@ export declare const dispatchRequest: (input: StartInput) => Effect.Effect<void,
 export declare const cancelRequest: (input: CancelExecutionInput) => Effect.Effect<{
     execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
-}, ExecutionWorkflowFailed, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | import("../wait/wait-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine>;
+}, ExecutionWorkflowFailed, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | import("../wait/wait-service").Service | import("../execution/execution-service").Service | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine>;
 export declare const poll: (executionId: string) => Effect.Effect<Option.Option<Workflow.Result<{
     readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     readonly status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";

package/dist/types/runtime/workspace/workspace-planner-service.d.ts

@@ -26,6 +26,7 @@ export declare class WorkspacePlannerError extends WorkspacePlannerError_base {
 }
 export interface EnsureInput {
     readonly executionId: Ids.ExecutionId;
+    readonly operationId: string;
     readonly agent: Agent.Definition;
     readonly toolDefinitions: ReadonlyArray<Tool.Definition>;
     readonly request?: Workspace.WorkspaceRequest;
@@ -38,6 +39,7 @@ export interface WorkspacePlan {
 export interface LifecycleInput {
     readonly executionId: Ids.ExecutionId;
     readonly now: number;
+    readonly operationKey?: string;
 }
 export interface FailureInput extends LifecycleInput {
     readonly metadata?: Shared.Metadata;

package/dist/types/schema/workflow-schema.d.ts

@@ -921,6 +921,7 @@ export declare const Definition: Schema.Union<readonly [Schema.Struct<{
 }>]>;
 export type Definition = typeof Definition.Type;
 export declare const canonicalDefinition: (definition: Definition) => string;
+export declare const sha256String: (value: string) => string;
 export declare const digestDefinition: (definition: Definition) => DefinitionDigest;
 export declare const DefinitionRevisionRecord: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Relay.WorkflowDefinitionId"> & {

package/dist/types/store-sql/execution/archive-compression.d.ts

@@ -0,0 +1,11 @@
+import { Effect, Schema } from "effect";
+declare const ArchiveCompressionError_base: Schema.Class<ArchiveCompressionError, Schema.TaggedStruct<"ArchiveCompressionError", {
+    readonly reason: Schema.Literals<readonly ["invalid-stream", "limit-exceeded"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchiveCompressionError extends ArchiveCompressionError_base {
+}
+export declare const collectBoundedBytes: (readable: ReadableStream<Uint8Array<ArrayBufferLike>>, maximumOutputBytes: number) => Effect.Effect<Uint8Array<ArrayBuffer>, ArchiveCompressionError, never>;
+export declare const compressGzip: (bytes: Uint8Array<ArrayBufferLike>, maximumOutputBytes: number) => Effect.Effect<Uint8Array<ArrayBuffer>, ArchiveCompressionError, never>;
+export declare const decompressGzip: (bytes: Uint8Array<ArrayBufferLike>, maximumOutputBytes: number) => Effect.Effect<Uint8Array<ArrayBuffer>, ArchiveCompressionError, never>;
+export {};

package/dist/types/store-sql/execution/event-history-file-system.d.ts

@@ -0,0 +1,7 @@
+import { Crypto, Layer, Path } from "effect";
+import { FileSystem } from "effect/FileSystem";
+import { Service } from "./event-history-store";
+export interface Options {
+    readonly rootDirectory: string;
+}
+export declare const layer: (options: Options) => Layer.Layer<Service, never, FileSystem | Crypto.Crypto | Path.Path>;

package/dist/types/store-sql/execution/event-history-store.d.ts

@@ -0,0 +1,93 @@
+import { Context, Crypto, Effect, Layer, Schema } from "effect";
+export declare const maximumHistoryObjectBytes: number;
+export declare const StoredHistoryObject: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly checksum: Schema.String;
+    readonly size: Schema.Int;
+}>;
+export interface StoredHistoryObject extends Schema.Schema.Type<typeof StoredHistoryObject> {
+}
+export declare const ByteRange: Schema.Struct<{
+    readonly offset: Schema.Int;
+    readonly length: Schema.Int;
+}>;
+export interface ByteRange extends Schema.Schema.Type<typeof ByteRange> {
+}
+export interface PutImmutableInput {
+    readonly bytes: Uint8Array;
+}
+export type HistoryObjectStat = {
+    readonly exists: false;
+} | {
+    readonly exists: true;
+    readonly size: number;
+};
+declare const HistoryObjectNotFound_base: Schema.Class<HistoryObjectNotFound, Schema.TaggedStruct<"HistoryObjectNotFound", {
+    readonly key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HistoryObjectNotFound extends HistoryObjectNotFound_base {
+}
+declare const HistoryObjectIntegrityError_base: Schema.Class<HistoryObjectIntegrityError, Schema.TaggedStruct<"HistoryObjectIntegrityError", {
+    readonly key: Schema.String;
+    readonly reason: Schema.Literals<readonly ["size-mismatch", "checksum-mismatch"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class HistoryObjectIntegrityError extends HistoryObjectIntegrityError_base {
+}
+declare const HistoryObjectSizeError_base: Schema.Class<HistoryObjectSizeError, Schema.TaggedStruct<"HistoryObjectSizeError", {
+    readonly operation: Schema.Literals<readonly ["put", "read", "delete"]>;
+    readonly source: Schema.Literals<readonly ["input", "descriptor", "stored"]>;
+    readonly size: Schema.Int;
+    readonly limit: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class HistoryObjectSizeError extends HistoryObjectSizeError_base {
+}
+declare const HistoryWriteError_base: Schema.Class<HistoryWriteError, Schema.TaggedStruct<"HistoryWriteError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HistoryWriteError extends HistoryWriteError_base {
+}
+declare const HistoryReadError_base: Schema.Class<HistoryReadError, Schema.TaggedStruct<"HistoryReadError", {
+    readonly reason: Schema.Literals<readonly ["invalid-range", "io"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HistoryReadError extends HistoryReadError_base {
+}
+declare const HistoryDeleteError_base: Schema.Class<HistoryDeleteError, Schema.TaggedStruct<"HistoryDeleteError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HistoryDeleteError extends HistoryDeleteError_base {
+}
+declare const HistoryDurabilityError_base: Schema.Class<HistoryDurabilityError, Schema.TaggedStruct<"HistoryDurabilityError", {
+    readonly operation: Schema.Literals<readonly ["put", "delete"]>;
+    readonly directory: Schema.String;
+    readonly reason: Schema.Literals<readonly ["BadArgument", "AlreadyExists", "BadResource", "Busy", "InvalidData", "NotFound", "PermissionDenied", "TimedOut", "UnexpectedEof", "Unknown", "WouldBlock", "WriteZero"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HistoryDurabilityError extends HistoryDurabilityError_base {
+}
+export type ReadFailure = HistoryObjectNotFound | HistoryObjectIntegrityError | HistoryObjectSizeError | HistoryReadError;
+export type PutFailure = HistoryObjectSizeError | HistoryWriteError | HistoryDurabilityError;
+export type DeleteFailure = HistoryObjectIntegrityError | HistoryObjectSizeError | HistoryDeleteError | HistoryDurabilityError;
+export interface Interface {
+    readonly putImmutable: (input: PutImmutableInput) => Effect.Effect<StoredHistoryObject, PutFailure>;
+    readonly read: (object: StoredHistoryObject, range?: ByteRange) => Effect.Effect<Uint8Array, ReadFailure>;
+    readonly stat: (object: StoredHistoryObject) => Effect.Effect<HistoryObjectStat, HistoryObjectSizeError | HistoryReadError>;
+    readonly delete: (object: StoredHistoryObject) => Effect.Effect<void, DeleteFailure>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/execution/event-history-store/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const validateHistoryObjectSize: (operation: "delete" | "put" | "read", source: "descriptor" | "input" | "stored", size: number | bigint) => Effect.Effect<number, HistoryObjectSizeError, never>;
+export declare const describeBytes: (crypto: Crypto.Crypto, bytes: Uint8Array<ArrayBufferLike>) => Effect.Effect<Schema.Struct.ReadonlySide<{
+    readonly key: Schema.String;
+    readonly checksum: Schema.String;
+    readonly size: Schema.Int;
+}, "Type">, import("effect/PlatformError").PlatformError, never>;
+export declare const readRange: (crypto: Crypto.Crypto, object: StoredHistoryObject, bytes: Uint8Array<ArrayBufferLike>, range?: ByteRange | undefined) => Effect.Effect<Uint8Array<ArrayBuffer>, HistoryObjectIntegrityError | HistoryReadError, never>;
+export declare const memoryLayer: Layer.Layer<Service, never, Crypto.Crypto>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+export declare const putImmutable: (input: PutImmutableInput) => Effect.Effect<StoredHistoryObject, PutFailure, Service>;
+export declare const read: (object: StoredHistoryObject, range?: ByteRange | undefined) => Effect.Effect<Uint8Array<ArrayBufferLike>, ReadFailure, Service>;
+export declare const stat: (object: StoredHistoryObject) => Effect.Effect<HistoryObjectStat, HistoryObjectSizeError | HistoryReadError, Service>;
+export declare const deleteObject: (object: StoredHistoryObject) => Effect.Effect<void, DeleteFailure, Service>;
+export {};

package/dist/types/store-sql/execution/execution-event-archive-codec.d.ts

@@ -0,0 +1,69 @@
+import { Execution } from "../../schema/index";
+import { Crypto, Effect, Schema } from "effect";
+export declare const maximumArchiveBlockBytes: number;
+export declare const maximumArchivePayloadBytes: number;
+export declare const maximumArchiveBlockEventCount = 4096;
+declare const Metadata: Schema.Union<readonly [Schema.Struct<{
+    readonly format: Schema.Literal<"relay.execution-event-archive-block">;
+    readonly encoding: Schema.Literal<"json">;
+    readonly execution_id: Schema.String;
+    readonly first_sequence: Schema.Int;
+    readonly last_sequence: Schema.Int;
+    readonly event_count: Schema.Int;
+    readonly checksum: Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly compression: Schema.Literal<"none">;
+    readonly payload_bytes: Schema.Int;
+}>, Schema.Struct<{
+    readonly format: Schema.Literal<"relay.execution-event-archive-block">;
+    readonly encoding: Schema.Literal<"json">;
+    readonly execution_id: Schema.String;
+    readonly first_sequence: Schema.Int;
+    readonly last_sequence: Schema.Int;
+    readonly event_count: Schema.Int;
+    readonly checksum: Schema.String;
+    readonly version: Schema.Literal<2>;
+    readonly compression: Schema.Literal<"gzip">;
+    readonly compressed_bytes: Schema.Int;
+    readonly uncompressed_bytes: Schema.Int;
+}>]>;
+export type Metadata = Schema.Schema.Type<typeof Metadata>;
+export interface DecodedBlock {
+    readonly metadata: Metadata;
+    readonly events: ReadonlyArray<Execution.ExecutionEvent>;
+}
+declare const ArchiveBlockCodecError_base: Schema.Class<ArchiveBlockCodecError, Schema.TaggedStruct<"ArchiveBlockCodecError", {
+    readonly reason: Schema.Literals<readonly ["invalid-events", "invalid-header", "invalid-framing", "limit-exceeded", "truncated", "checksum-mismatch", "invalid-payload"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArchiveBlockCodecError extends ArchiveBlockCodecError_base {
+}
+export declare const encodeBlock: (input: readonly Execution.ExecutionEvent[]) => Effect.Effect<Uint8Array<ArrayBuffer>, ArchiveBlockCodecError, Crypto.Crypto>;
+export declare const decodeBlock: (block: Uint8Array<ArrayBufferLike>) => Effect.Effect<{
+    metadata: Schema.Struct.ReadonlySide<{
+        readonly format: Schema.Literal<"relay.execution-event-archive-block">;
+        readonly encoding: Schema.Literal<"json">;
+        readonly execution_id: Schema.String;
+        readonly first_sequence: Schema.Int;
+        readonly last_sequence: Schema.Int;
+        readonly event_count: Schema.Int;
+        readonly checksum: Schema.String;
+        readonly version: Schema.Literal<1>;
+        readonly compression: Schema.Literal<"none">;
+        readonly payload_bytes: Schema.Int;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly format: Schema.Literal<"relay.execution-event-archive-block">;
+        readonly encoding: Schema.Literal<"json">;
+        readonly execution_id: Schema.String;
+        readonly first_sequence: Schema.Int;
+        readonly last_sequence: Schema.Int;
+        readonly event_count: Schema.Int;
+        readonly checksum: Schema.String;
+        readonly version: Schema.Literal<2>;
+        readonly compression: Schema.Literal<"gzip">;
+        readonly compressed_bytes: Schema.Int;
+        readonly uncompressed_bytes: Schema.Int;
+    }, "Type">;
+    events: readonly Execution.ExecutionEvent[];
+}, ArchiveBlockCodecError, Crypto.Crypto>;
+export {};

package/dist/types/store-sql/execution/execution-event-archive-repository-memory.d.ts

@@ -0,0 +1,28 @@
+import { Execution, Ids } from "../../schema/index";
+import { Crypto, Effect, Layer } from "effect";
+import { Service as EventHistoryStore } from "./event-history-store";
+import { Service as MemoryEventHeadService } from "./execution-event-head-memory";
+import { Service as EventRepositoryService } from "./execution-event-repository";
+import type { ArchiveIntegrityError, ArchiveGenerationConflict, ArchiveHeadNotFound, ArchiveManifestInvalid, ArchivePublicationStale, ArchiveRepositoryError, Manifest, PublicationInput, Service } from "./execution-event-archive-repository";
+export declare const makeMemoryLayer: (repository: {
+    readonly validatePublication: typeof import("./execution-event-archive-repository").validatePublication;
+    readonly verifyPublication: (input: PublicationInput) => Effect.Effect<{
+        readonly input: PublicationInput;
+        readonly events: ReadonlyArray<Execution.ExecutionEvent>;
+    }, ArchiveManifestInvalid, import("./event-history-store").Service | import("effect").Crypto.Crypto>;
+    readonly ArchiveIntegrityError: typeof ArchiveIntegrityError;
+    readonly ArchiveGenerationConflict: typeof ArchiveGenerationConflict;
+    readonly ArchiveHeadNotFound: typeof ArchiveHeadNotFound;
+    readonly ArchiveManifestInvalid: typeof ArchiveManifestInvalid;
+    readonly ArchivePublicationStale: typeof ArchivePublicationStale;
+    readonly ArchiveRepositoryError: typeof ArchiveRepositoryError;
+    readonly Service: typeof Service;
+}, restored?: {
+    readonly manifests?: ReadonlyArray<Manifest>;
+    readonly pointers?: ReadonlyArray<{
+        readonly tenantId: Ids.TenantId;
+        readonly executionId: Ids.ExecutionId;
+        readonly generation: number | null;
+        readonly archivedThrough: number | null;
+    }>;
+}) => Layer.Layer<Service, never, Crypto.Crypto | MemoryEventHeadService | EventRepositoryService | EventHistoryStore>;

package/dist/types/store-sql/execution/execution-event-archive-repository-sql.d.ts

@@ -0,0 +1,19 @@
+import { Crypto, Effect, Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Service as EventHistoryStore } from "./event-history-store";
+import type { ArchiveIntegrityError, ArchiveGenerationConflict, ArchiveHeadNotFound, ArchiveManifestInvalid, ArchivePublicationStale, ArchiveRepositoryError, PublicationInput, Service } from "./execution-event-archive-repository";
+export declare const makeLayer: (repository: {
+    readonly validatePublication: typeof import("./execution-event-archive-repository").validatePublication;
+    readonly verifyPublication: (input: PublicationInput) => Effect.Effect<{
+        readonly input: PublicationInput;
+        readonly events: ReadonlyArray<import("../../schema/index").Execution.ExecutionEvent>;
+    }, ArchiveManifestInvalid, import("./event-history-store").Service | import("effect").Crypto.Crypto>;
+    readonly ArchiveIntegrityError: typeof ArchiveIntegrityError;
+    readonly ArchiveGenerationConflict: typeof ArchiveGenerationConflict;
+    readonly ArchiveHeadNotFound: typeof ArchiveHeadNotFound;
+    readonly ArchiveManifestInvalid: typeof ArchiveManifestInvalid;
+    readonly ArchivePublicationStale: typeof ArchivePublicationStale;
+    readonly ArchiveRepositoryError: typeof ArchiveRepositoryError;
+    readonly Manifest: typeof import("./execution-event-archive-repository").Manifest;
+    readonly Service: typeof Service;
+}) => Layer.Layer<Service, never, Crypto.Crypto | EventHistoryStore | SqlClient>;