@relayfx/sdk 0.3.1 → 0.3.2

package/dist/types/runtime/session/session-store-service.d.ts

@@ -6,7 +6,10 @@ export type Interface = Session.Interface;
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/session/session-store-service/Service", Session.Interface>;
 export declare class Service extends Service_base {
 }
-export declare const make: (sessionId: string & import("effect/Brand").Brand<"Relay.SessionId">, entryScope?: string | undefined) => Effect.Effect<Session.Interface, never, SessionRepository.Service>;
+export interface MakeOptions {
+    readonly onCheckpointCommitted?: (result: Session.CheckpointAppend) => Effect.Effect<void, Session.SessionStoreError | Session.SessionConflict>;
+}
+export declare const make: (sessionId: string & import("effect/Brand").Brand<"Relay.SessionId">, entryScope?: string | undefined, makeOptions?: MakeOptions | undefined) => Effect.Effect<Session.Interface, never, SessionRepository.Service>;
 export declare const serviceLayer: {
     (sessionId: Ids.SessionId, entryScope?: string): Layer.Layer<Service, never, SessionRepository.Service>;
     (entryScope?: string): (sessionId: Ids.SessionId) => Layer.Layer<Service, never, SessionRepository.Service>;

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

@@ -0,0 +1,121 @@
+import { Execution, Ids, Shared, Tool } from "../../schema/index";
+import { Tool as AiTool } from "effect/unstable/ai";
+import { Context, Effect, Layer, Schema } from "effect";
+declare const ToolNotRegistered_base: Schema.Class<ToolNotRegistered, Schema.TaggedStruct<"ToolNotRegistered", {
+    readonly tool_name: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolNotRegistered extends ToolNotRegistered_base {
+}
+declare const ToolPermissionDenied_base: Schema.Class<ToolPermissionDenied, Schema.TaggedStruct<"ToolPermissionDenied", {
+    readonly tool_name: Schema.String;
+    readonly permission_name: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolPermissionDenied extends ToolPermissionDenied_base {
+}
+declare const ToolInputInvalid_base: Schema.Class<ToolInputInvalid, Schema.TaggedStruct<"ToolInputInvalid", {
+    readonly tool_name: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolInputInvalid extends ToolInputInvalid_base {
+}
+declare const ToolExecutionFailed_base: Schema.Class<ToolExecutionFailed, Schema.TaggedStruct<"ToolExecutionFailed", {
+    readonly tool_name: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolExecutionFailed extends ToolExecutionFailed_base {
+}
+declare const ToolExecutionWaitRequested_base: Schema.Class<ToolExecutionWaitRequested, Schema.TaggedStruct<"ToolExecutionWaitRequested", {
+    readonly tool_name: Schema.String;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolExecutionWaitRequested extends ToolExecutionWaitRequested_base {
+}
+declare const ToolRuntimeError_base: Schema.Class<ToolRuntimeError, Schema.TaggedStruct<"ToolRuntimeError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolRuntimeError extends ToolRuntimeError_base {
+}
+export interface ToolExecutionContext {
+    readonly executionId: Ids.ExecutionId;
+    readonly call: Tool.Call;
+    readonly permissions: ReadonlyArray<Tool.Permission>;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly createdAt: number;
+    readonly idempotencyKey: string;
+}
+export interface ToolCallInfoData extends ToolExecutionContext {
+}
+declare const ToolCallInfo_base: Context.ServiceClass<ToolCallInfo, "@relayfx/runtime/tool/tool-runtime-contract/ToolCallInfo", ToolCallInfoData>;
+export declare class ToolCallInfo extends ToolCallInfo_base {
+}
+export interface RegisteredTool {
+    readonly definition: Tool.Definition;
+    readonly tool: AiTool.Any;
+    readonly placement?: Tool.Placement | undefined;
+    readonly requiredPermissions?: ReadonlyArray<string>;
+    readonly validateInput?: (input: Shared.JsonValue) => Effect.Effect<void, ToolInputInvalid>;
+    readonly run?: ((input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>) | undefined;
+}
+export interface ToolOptions<Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>> {
+    readonly description: string;
+    readonly input: Input;
+    readonly output: Output;
+    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
+    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
+    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
+    readonly needsApproval?: boolean | undefined;
+    readonly metadata?: Shared.Metadata | undefined;
+    readonly placement?: Tool.Placement | undefined;
+    readonly run: (input: Input["Type"], context: ToolExecutionContext) => Effect.Effect<Output["Type"], ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, ToolCallInfo>;
+}
+export interface DynamicToolOptions {
+    readonly description: string;
+    readonly inputSchema: Shared.JsonValue;
+    readonly outputSchema: Shared.JsonValue;
+    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
+    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
+    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
+    readonly needsApproval?: boolean | undefined;
+    readonly metadata?: Shared.Metadata | undefined;
+    readonly placement?: Tool.Placement | undefined;
+    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>;
+}
+export interface ToolkitToolOptions {
+    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
+    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
+    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
+    readonly needsApproval?: boolean | undefined;
+    readonly metadata?: Shared.Metadata | undefined;
+    readonly placement?: Tool.Placement | undefined;
+}
+export interface PlacedToolOptions {
+    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
+    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
+    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
+    readonly needsApproval?: boolean | undefined;
+    readonly metadata?: Shared.Metadata | undefined;
+}
+export type ToolkitRegistrationOptions = ToolkitToolOptions | ((tool: AiTool.Any) => ToolkitToolOptions);
+export interface RunInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly call: Tool.Call;
+    readonly permissions: ReadonlyArray<Tool.Permission>;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly createdAt: number;
+    readonly extraTools?: ReadonlyArray<RegisteredTool>;
+    readonly transformResult?: (result: Tool.Result) => Effect.Effect<Tool.Result, ToolRuntimeError>;
+}
+export type RunError = ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError;
+export interface Interface {
+    readonly register: (tool: RegisteredTool) => Effect.Effect<void>;
+    readonly definitions: Effect.Effect<ReadonlyArray<Tool.Definition>>;
+    readonly registeredTools: Effect.Effect<ReadonlyArray<RegisteredTool>>;
+    readonly run: (input: RunInput) => Effect.Effect<Tool.Result, RunError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/tool/tool-runtime-contract/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+export {};

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

@@ -1,117 +1,12 @@
-import { Execution, Ids, Shared, Tool } from "../../schema/index";
+import { Tool } from "../../schema/index";
 import { ToolCallRepository } from "../../store-sql/portable";
 import { Tool as AiTool, Toolkit } from "effect/unstable/ai";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Effect, Layer, Schema } from "effect";
 import { Service as EventLogService } from "../execution/event-log-service";
 import { Service as WaitServiceService } from "../wait/wait-service";
-declare const ToolNotRegistered_base: Schema.Class<ToolNotRegistered, Schema.TaggedStruct<"ToolNotRegistered", {
-    readonly tool_name: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolNotRegistered extends ToolNotRegistered_base {
-}
-declare const ToolPermissionDenied_base: Schema.Class<ToolPermissionDenied, Schema.TaggedStruct<"ToolPermissionDenied", {
-    readonly tool_name: Schema.String;
-    readonly permission_name: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolPermissionDenied extends ToolPermissionDenied_base {
-}
-declare const ToolInputInvalid_base: Schema.Class<ToolInputInvalid, Schema.TaggedStruct<"ToolInputInvalid", {
-    readonly tool_name: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolInputInvalid extends ToolInputInvalid_base {
-}
-declare const ToolExecutionFailed_base: Schema.Class<ToolExecutionFailed, Schema.TaggedStruct<"ToolExecutionFailed", {
-    readonly tool_name: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolExecutionFailed extends ToolExecutionFailed_base {
-}
-declare const ToolExecutionWaitRequested_base: Schema.Class<ToolExecutionWaitRequested, Schema.TaggedStruct<"ToolExecutionWaitRequested", {
-    readonly tool_name: Schema.String;
-    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolExecutionWaitRequested extends ToolExecutionWaitRequested_base {
-}
-declare const ToolRuntimeError_base: Schema.Class<ToolRuntimeError, Schema.TaggedStruct<"ToolRuntimeError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolRuntimeError extends ToolRuntimeError_base {
-}
-export interface ToolExecutionContext {
-    readonly executionId: Ids.ExecutionId;
-    readonly call: Tool.Call;
-    readonly permissions: ReadonlyArray<Tool.Permission>;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-    readonly idempotencyKey: string;
-}
-export interface ToolCallInfoData extends ToolExecutionContext {
-}
-declare const ToolCallInfo_base: Context.ServiceClass<ToolCallInfo, "@relayfx/runtime/tool/tool-runtime-service/ToolCallInfo", ToolCallInfoData>;
-export declare class ToolCallInfo extends ToolCallInfo_base {
-}
-export interface RegisteredTool {
-    readonly definition: Tool.Definition;
-    readonly tool: AiTool.Any;
-    readonly placement?: Tool.Placement | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string>;
-    readonly validateInput?: (input: Shared.JsonValue) => Effect.Effect<void, ToolInputInvalid>;
-    readonly run?: ((input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>) | undefined;
-}
-export interface ToolOptions<Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>> {
-    readonly description: string;
-    readonly input: Input;
-    readonly output: Output;
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-    readonly placement?: Tool.Placement | undefined;
-    readonly run: (input: Input["Type"], context: ToolExecutionContext) => Effect.Effect<Output["Type"], ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, ToolCallInfo>;
-}
-export interface DynamicToolOptions {
-    readonly description: string;
-    readonly inputSchema: Shared.JsonValue;
-    readonly outputSchema: Shared.JsonValue;
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-    readonly placement?: Tool.Placement | undefined;
-    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>;
-}
-export interface ToolkitToolOptions {
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-    readonly placement?: Tool.Placement | undefined;
-}
-export type ToolkitRegistrationOptions = ToolkitToolOptions | ((tool: AiTool.Any) => ToolkitToolOptions);
-export interface RunInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly call: Tool.Call;
-    readonly permissions: ReadonlyArray<Tool.Permission>;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-    readonly extraTools?: ReadonlyArray<RegisteredTool>;
-    readonly transformResult?: (result: Tool.Result) => Effect.Effect<Tool.Result, ToolRuntimeError>;
-}
-export interface Interface {
-    readonly register: (tool: RegisteredTool) => Effect.Effect<void>;
-    readonly definitions: Effect.Effect<ReadonlyArray<Tool.Definition>>;
-    readonly registeredTools: Effect.Effect<ReadonlyArray<RegisteredTool>>;
-    readonly run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, never>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/tool/tool-runtime-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
+export * from "./tool-runtime-contract";
+import { Service } from "./tool-runtime-contract";
+import type { DynamicToolOptions, PlacedToolOptions, RegisteredTool, RunInput, ToolkitRegistrationOptions, ToolOptions } from "./tool-runtime-contract";
 export declare const toolFromRegistered: (tool: RegisteredTool) => AiTool.Any;
 export declare const toolsFromToolkit: {
     <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.WithHandler<Tools>, options?: ToolkitRegistrationOptions): ReadonlyArray<RegisteredTool>;
@@ -125,13 +20,6 @@ export declare const dynamicTool: {
     <const Name extends string>(name: Name, options: DynamicToolOptions): RegisteredTool;
     (options: DynamicToolOptions): <const Name extends string>(name: Name) => RegisteredTool;
 };
-export interface PlacedToolOptions {
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-}
 export declare const clientTool: {
     (modelTool: AiTool.Any, options?: PlacedToolOptions): RegisteredTool;
     (options?: PlacedToolOptions): (modelTool: AiTool.Any) => RegisteredTool;
@@ -154,9 +42,7 @@ export declare const memoryLayerFromToolkit: {
     <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<Service, never, Exclude<AiTool.HandlersFor<Tools>, ToolCallRepository.Service | EventLogService | WaitServiceService>>;
     (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<Service, never, Exclude<AiTool.HandlersFor<Tools>, ToolCallRepository.Service | EventLogService | WaitServiceService>>;
 };
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const register: (registeredTool: RegisteredTool) => Effect.Effect<void, never, Service>;
 export declare const definitions: () => Effect.Effect<readonly Tool.Definition[], never, Service>;
 export declare const registeredTools: () => Effect.Effect<readonly RegisteredTool[], never, Service>;
-export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, ToolExecutionFailed | ToolExecutionWaitRequested | ToolInputInvalid | ToolNotRegistered | ToolPermissionDenied | ToolRuntimeError, Service>;
-export {};
+export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, import("./tool-runtime-contract").RunError, Service>;

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

@@ -1,7 +1,9 @@
+import { AgentEvent } from "@batonfx/core";
 import { Agent, Ids } from "../../schema/index";
 import { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "../../store-sql/portable";
 import { Workflow, WorkflowEngine } from "effect/unstable/workflow";
-import { Effect, Layer, Option, Schema } from "effect";
+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";
@@ -9,9 +11,17 @@ 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", {
     readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+    readonly terminal_failure: Schema.optionalKey<Schema.Union<readonly [typeof AgentLoopError, typeof AgentLoopBudgetExceeded]>>;
+}>, Cause.YieldableError>;
 export declare class ExecutionWorkflowFailed extends ExecutionWorkflowFailed_base {
 }
+declare const AgentCheckpointCompatibilityError_base: Schema.Class<AgentCheckpointCompatibilityError, Schema.TaggedStruct<"AgentCheckpointCompatibilityError", {
+    readonly message: Schema.String;
+}>, Cause.YieldableError>;
+export declare class AgentCheckpointCompatibilityError extends AgentCheckpointCompatibilityError_base {
+}
+export declare const ExecutionWorkflowError: Schema.Union<readonly [typeof ExecutionWorkflowFailed, typeof AgentCheckpointCompatibilityError]>;
+export type ExecutionWorkflowError = typeof ExecutionWorkflowError.Type;
 export declare const StartInput: Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -184,14 +194,7 @@ export declare const StartInput: Schema.Struct<{
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
-    readonly resume_tool_call: Schema.optionalKey<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-        };
-        readonly name: Schema.String;
-        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>>;
+    readonly resume_suspension: Schema.optionalKey<typeof AgentEvent.AgentSuspended>;
     readonly workflow_generation: Schema.optionalKey<Schema.Int>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>;
@@ -281,6 +284,7 @@ export declare const ActivityNames: {
     readonly resumeWorkspace: (key: string) => string;
     readonly releaseWorkspace: "Relay/Execution/Start/ReleaseWorkspace";
     readonly complete: (turn: number) => string;
+    readonly failIncompatibleCheckpoint: "Relay/Execution/Start/FailIncompatibleCheckpoint";
     readonly checkQueuedChildCancellation: "Relay/Execution/Start/CheckQueuedChildCancellation";
     readonly notifyParent: (status: ChildTerminalStatus) => string;
     readonly continueAsNew: (turn: number) => string;
@@ -298,6 +302,7 @@ export declare const ActivityNameTemplates: {
     readonly resumeWorkspace: "Relay/Execution/Start/ResumeWorkspace/:key";
     readonly releaseWorkspace: "Relay/Execution/Start/ReleaseWorkspace";
     readonly complete: "Relay/Execution/Start/Complete/:turn";
+    readonly failIncompatibleCheckpoint: "Relay/Execution/Start/FailIncompatibleCheckpoint";
     readonly checkQueuedChildCancellation: "Relay/Execution/Start/CheckQueuedChildCancellation";
     readonly notifyParent: "Relay/Execution/Start/NotifyParent/:status";
     readonly continueAsNew: "Relay/Execution/Start/ContinueAsNew/:turn";
@@ -474,14 +479,7 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
-    readonly resume_tool_call: Schema.optionalKey<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-        };
-        readonly name: Schema.String;
-        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>>;
+    readonly resume_suspension: Schema.optionalKey<typeof AgentEvent.AgentSuspended>;
     readonly workflow_generation: Schema.optionalKey<Schema.Int>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, Schema.Struct<{
@@ -494,7 +492,7 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     }>;
     readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflowFailed>;
+}>, Schema.Union<readonly [typeof ExecutionWorkflowFailed, typeof AgentCheckpointCompatibilityError]>>;
 export declare const sessionEntryScope: {
     (input: StartInput, turn: number): string;
     (turn: number): (input: StartInput) => string;
@@ -504,11 +502,11 @@ interface StartOptions<Discard extends boolean> {
     readonly discard?: Discard;
 }
 export declare const start: {
-    <const Discard extends boolean = false>(input: StartInput, options?: StartOptions<Discard>): Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
-    <const Discard extends boolean = false>(options?: StartOptions<Discard>): (input: StartInput) => Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
+    <const Discard extends boolean = false>(input: StartInput, options?: StartOptions<Discard>): Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowError, WorkflowEngine.WorkflowEngine>;
+    <const Discard extends boolean = false>(options?: StartOptions<Discard>): (input: StartInput) => Effect.Effect<Discard extends true ? string : StartResult, ExecutionWorkflowError, WorkflowEngine.WorkflowEngine>;
 };
-export declare const startRequest: (input: StartInput) => Effect.Effect<StartResult, ExecutionWorkflowFailed, ExecutionRepository.Service | import("../wait/wait-service").Service | WorkflowEngine.WorkflowEngine>;
-export declare const dispatchRequest: (input: StartInput) => Effect.Effect<void, ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
+export declare const startRequest: (input: StartInput) => Effect.Effect<StartResult, AgentCheckpointCompatibilityError | ExecutionWorkflowFailed, ExecutionRepository.Service | import("../wait/wait-service").Service | WorkflowEngine.WorkflowEngine>;
+export declare const dispatchRequest: (input: StartInput) => Effect.Effect<void, AgentCheckpointCompatibilityError | ExecutionWorkflowFailed, WorkflowEngine.WorkflowEngine>;
 export declare const cancelRequest: (input: CancelExecutionInput) => Effect.Effect<{
     execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
@@ -521,7 +519,7 @@ export declare const poll: (executionId: string) => Effect.Effect<Option.Option<
     readonly metadata?: {
         readonly [x: string]: Schema.Json;
     };
-}, ExecutionWorkflowFailed>>, never, WorkflowEngine.WorkflowEngine>;
+}, AgentCheckpointCompatibilityError | ExecutionWorkflowFailed>>, never, WorkflowEngine.WorkflowEngine>;
 export declare const resume: (executionId: string) => Effect.Effect<void, never, WorkflowEngine.WorkflowEngine>;
 export declare const workflowExecutionId: (input: StartInput) => Effect.Effect<string, never, never>;
 export declare const workflowExecutionIdForExecution: {

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

@@ -97,6 +97,9 @@ export interface RecursTurnPolicySnapshot {
     readonly kind: "recurs";
     readonly count: number;
 }
+export interface ForeverTurnPolicySnapshot {
+    readonly kind: "forever";
+}
 export interface UntilToolCallTurnPolicySnapshot {
     readonly kind: "until-tool-call";
     readonly name: string;
@@ -106,7 +109,7 @@ export interface BothTurnPolicySnapshot {
     readonly first: TurnPolicySnapshot;
     readonly second: TurnPolicySnapshot;
 }
-export type TurnPolicySnapshot = RecursTurnPolicySnapshot | UntilToolCallTurnPolicySnapshot | BothTurnPolicySnapshot;
+export type TurnPolicySnapshot = ForeverTurnPolicySnapshot | RecursTurnPolicySnapshot | UntilToolCallTurnPolicySnapshot | BothTurnPolicySnapshot;
 export declare const maxTurnPolicySnapshotDepth = 16;
 export declare const maxTurnPolicySnapshotNodes = 64;
 export declare const TurnPolicySnapshot: Schema.Codec<TurnPolicySnapshot>;

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

@@ -382,8 +382,19 @@ export declare const ChildRunAccepted: Schema.Struct<{
 export interface ChildRunAccepted extends Schema.Schema.Type<typeof ChildRunAccepted> {
 }
 export declare const childSessionId: (childExecutionId: ChildExecutionId) => string & import("effect/Brand").Brand<"Relay.SessionId">;
-export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
 export type ExecutionEventType = typeof ExecutionEventType.Type;
+export declare const CompactionCommittedEventData: Schema.Struct<{
+    readonly checkpoint_id: Schema.brand<Schema.String, "Relay.SessionEntryId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionEntryId">;
+    };
+    readonly session_id: Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    };
+    readonly summary_present: Schema.Boolean;
+}>;
+export interface CompactionCommittedEventData extends Schema.Schema.Type<typeof CompactionCommittedEventData> {
+}
 export declare const ExecutionEvent: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Relay.EventId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EventId">;
@@ -394,7 +405,7 @@ export declare const ExecutionEvent: Schema.Struct<{
     readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
     }>;
-    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.toolcall.delta", "model.output.completed", "model.usage.reported", "agent.compaction.committed", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "child_fan_out.created", "child_fan_out.member.admitted", "child_fan_out.member.terminal", "child_fan_out.terminal", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
     readonly sequence: Schema.Int;
     readonly cursor: Schema.String;
     readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{

package/dist/types/schema/index.d.ts

@@ -7,6 +7,7 @@ export * as Entity from "./entity-schema";
 export * as Execution from "./execution-schema";
 export * as Ids from "./ids-schema";
 export * as Inbox from "./inbox-schema";
+export * as Pagination from "./pagination-schema";
 export * as Presence from "./presence-schema";
 export * as Schedule from "./schedule-schema";
 export * as Shared from "./shared-schema";

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

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+export declare const ExecutionCursorCodec: Schema.decodeTo<Schema.fromJsonString<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly at: Schema.Int;
+}>>, Schema.StringFromBase64Url, never, never>;
+export declare const ExecutionCursor: Schema.String;
+export type ExecutionCursor = typeof ExecutionCursor.Type;
+export declare const SessionCursorCodec: Schema.decodeTo<Schema.fromJsonString<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.SessionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+    };
+    readonly at: Schema.Int;
+}>>, Schema.StringFromBase64Url, never, never>;
+export declare const SessionCursor: Schema.String;
+export type SessionCursor = typeof SessionCursor.Type;

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

@@ -11,3 +11,7 @@ export declare const NonEmptyString: Schema.String;
 export type NonEmptyString = typeof NonEmptyString.Type;
 export declare const canonicalValue: (value: unknown) => unknown;
 export declare const canonicalString: (value: unknown) => string;
+export declare const canonicalEquals: {
+    (right: unknown): (left: unknown) => boolean;
+    (left: unknown, right: unknown): boolean;
+};

package/dist/types/store-sql/schema/relay-schema.d.ts

@@ -274,6 +274,12 @@ export declare const relayWorkflowDefinitionRevisions: import("drizzle-orm/pg-co
                     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
                 };
             }, "Type"> | {
+                readonly id: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
+                readonly kind: "child";
+                readonly address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
+                readonly preset_name?: string;
+                readonly input?: import("effect/Schema").Json;
+            } | {
                 readonly id: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
                 readonly kind: "tool";
                 readonly tool_name: string;
@@ -283,12 +289,6 @@ export declare const relayWorkflowDefinitionRevisions: import("drizzle-orm/pg-co
                 readonly kind: "cancellation";
                 readonly operation: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
                 readonly on_cancel?: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
-            } | {
-                readonly id: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
-                readonly kind: "child";
-                readonly address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
-                readonly preset_name?: string;
-                readonly input?: import("effect/Schema").Json;
             })[];
             readonly metadata?: {
                 readonly [x: string]: import("effect/Schema").Json;
@@ -507,6 +507,12 @@ export declare const relayWorkflowDefinitionRevisions: import("drizzle-orm/pg-co
                         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
                     };
                 }, "Type"> | {
+                    readonly id: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
+                    readonly kind: "child";
+                    readonly address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
+                    readonly preset_name?: string;
+                    readonly input?: import("effect/Schema").Json;
+                } | {
                     readonly id: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
                     readonly kind: "tool";
                     readonly tool_name: string;
@@ -516,12 +522,6 @@ export declare const relayWorkflowDefinitionRevisions: import("drizzle-orm/pg-co
                     readonly kind: "cancellation";
                     readonly operation: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
                     readonly on_cancel?: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
-                } | {
-                    readonly id: string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
-                    readonly kind: "child";
-                    readonly address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
-                    readonly preset_name?: string;
-                    readonly input?: import("effect/Schema").Json;
                 })[];
                 readonly metadata?: {
                     readonly [x: string]: import("effect/Schema").Json;