@relayfx/sdk 0.2.15 → 0.2.16

package/dist/types/store-sql/session/context-epoch-repository.d.ts

@@ -22,14 +22,14 @@ export interface Interface {
     readonly save: (input: SaveInput) => Effect.Effect<ContextEpochRecord, ContextEpochRepositoryError>;
     readonly get: (executionId: Ids.ExecutionId) => Effect.Effect<ContextEpochRecord | undefined, ContextEpochRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ContextEpochRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/session/context-epoch-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const ContextEpochRow: Schema.Struct<{
     readonly execution_id: Schema.String;
     readonly baseline: Schema.String;
     readonly dynamic_source_ids_json: Schema.Unknown;
-    readonly opened_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly opened_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

package/dist/types/store-sql/session/session-repository.d.ts

@@ -195,7 +195,7 @@ export interface Interface {
     readonly setLeaf: (input: SetLeafInput) => Effect.Effect<void, SessionRepositoryError>;
     readonly leaf: (sessionId: Ids.SessionId) => Effect.Effect<Ids.SessionEntryId | null, SessionRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/SessionRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/session/session-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const SessionRow: Schema.Struct<{
@@ -203,8 +203,8 @@ export declare const SessionRow: Schema.Struct<{
     readonly root_address_id: Schema.String;
     readonly leaf_entry_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const SessionEntryRow: Schema.Struct<{
     readonly id: Schema.String;
@@ -212,13 +212,13 @@ export declare const SessionEntryRow: Schema.Struct<{
     readonly parent_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
     readonly tag: Schema.String;
     readonly payload_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const layerFromTenant: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const create: (input: CreateSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError | DuplicateSession, Service>;
+export declare const create: (input: CreateSessionInput) => Effect.Effect<SessionRecord, DuplicateSession | SessionRepositoryError, Service>;
 export declare const ensure: (input: EnsureSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError, Service>;
 export declare const get: (id: string & import("effect/Brand").Brand<"Relay.SessionId">) => Effect.Effect<SessionRecord | undefined, SessionRepositoryError, Service>;
 export declare const list: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, SessionRepositoryError, Service>;

package/dist/types/store-sql/skill/skill-definition-repository.d.ts

@@ -48,34 +48,34 @@ export interface Interface {
     readonly put: (input: PutSkillDefinitionInput) => Effect.Effect<SkillDefinitionRecord, SkillDefinitionRepositoryError>;
     readonly get: (id: Ids.SkillDefinitionId) => Effect.Effect<SkillDefinitionRecord | undefined, SkillDefinitionRepositoryError>;
     readonly getRevision: (input: GetSkillDefinitionRevisionInput) => Effect.Effect<SkillDefinitionRevisionRecord | undefined, SkillDefinitionRepositoryError>;
-    readonly list: () => Effect.Effect<ReadonlyArray<SkillDefinitionRecord>, SkillDefinitionRepositoryError>;
+    readonly list: (_?: never) => Effect.Effect<ReadonlyArray<SkillDefinitionRecord>, SkillDefinitionRepositoryError>;
     readonly listRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<ReadonlyArray<SkillDefinitionRevisionRecord>, SkillDefinitionRepositoryError>;
     readonly pinExecution: (input: PinExecutionSkillsInput) => Effect.Effect<ReadonlyArray<ExecutionSkillPinRecord>, SkillDefinitionRepositoryError>;
     readonly listPins: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<ExecutionSkillPinRecord>, SkillDefinitionRepositoryError>;
     readonly getPinned: (input: GetPinnedSkillInput) => Effect.Effect<ExecutionSkillPinRecord | undefined, SkillDefinitionRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/SkillDefinitionRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/skill/skill-definition-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const SkillDefinitionRow: Schema.Struct<{
     readonly id: Schema.String;
-    readonly current_revision: Schema.Number;
+    readonly current_revision: Schema.Finite;
     readonly definition_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const SkillDefinitionRevisionRow: Schema.Struct<{
     readonly skill_definition_id: Schema.String;
-    readonly revision: Schema.Number;
+    readonly revision: Schema.Finite;
     readonly definition_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const ExecutionSkillPinRow: Schema.Struct<{
     readonly execution_id: Schema.String;
     readonly skill_definition_id: Schema.String;
-    readonly skill_definition_revision: Schema.Number;
+    readonly skill_definition_revision: Schema.Finite;
     readonly skill_definition_snapshot_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

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

@@ -71,10 +71,10 @@ export interface Interface {
     readonly remove: (input: RemoveInput) => Effect.Effect<State.StateRecordView | undefined, StateVersionConflict | StateIdempotencyConflict | ExecutionStateExecutionNotFound | ExecutionStateRepositoryError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<State.StateRecordView>, ExecutionStateRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionStateRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/state/execution-state-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const memoryLayer: Layer.Layer<Service, never, ExecutionEventRepositoryService | ExecutionRepositoryService>;
-export declare const layer: Layer.Layer<Service, never, SqlClient | ExecutionEventRepositoryService>;
+export declare const layer: Layer.Layer<Service, never, ExecutionEventRepositoryService | SqlClient>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export {};

package/dist/types/store-sql/steering/steering-repository.d.ts

@@ -47,24 +47,24 @@ export interface Interface {
     readonly appendForRunning: (input: AppendInput) => Effect.Effect<SteeringMessageRecord, SteeringRepositoryError>;
     readonly drainUnconsumed: (input: DrainInput) => Effect.Effect<DrainResult, SteeringRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/SteeringRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/steering/steering-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const SteeringMessageRow: Schema.Struct<{
     readonly execution_id: Schema.String;
     readonly kind: Schema.Literals<readonly ["steering", "follow_up"]>;
-    readonly sequence: Schema.Union<readonly [Schema.Number, Schema.String]>;
+    readonly sequence: Schema.Union<readonly [Schema.Finite, Schema.String]>;
     readonly content_json: Schema.Unknown;
     readonly drain_id: Schema.NullishOr<Schema.String>;
-    readonly consumed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly consumed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const SteeringDrainRow: Schema.Struct<{
     readonly execution_id: Schema.String;
     readonly kind: Schema.Literals<readonly ["steering", "follow_up"]>;
     readonly drain_id: Schema.String;
     readonly message_sequences_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

package/dist/types/store-sql/tenant/tenant-id.d.ts

@@ -3,13 +3,13 @@ import { Context, Effect, Layer } from "effect";
 export interface Interface {
     readonly tenantId: Ids.TenantId;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/TenantId", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/tenant/tenant-id/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const make: (tenantId: Ids.TenantId) => Interface;
 export declare const layer: (tenantId: Ids.TenantId) => Layer.Layer<Service, never, never>;
 export declare const systemLayer: Layer.Layer<Service, never, never>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
-export declare const testLayer: (tenantId: Ids.TenantId) => Layer.Layer<Service, never, never>;
+export declare const testLayer: typeof layer;
 export declare const current: () => Effect.Effect<string & import("effect/Brand").Brand<"Relay.TenantId">, never, never>;
 export {};

package/dist/types/store-sql/tool/tool-call-repository.d.ts

@@ -155,7 +155,10 @@ export interface FailOpenForExecutionInput {
     readonly failedAt: number;
 }
 export type ToolCallStateError = ToolCallNotFound | ToolCallConflict | ToolCallTransitionRejected | ToolOutcomeConflict | ToolClaimRejected | ToolCallRepositoryError;
-export declare const toolCallIdempotencyKey: (tenantId: Ids.TenantId, executionId: Ids.ExecutionId, callId: Ids.ToolCallId) => string;
+export declare const toolCallIdempotencyKey: {
+    (executionId: Ids.ExecutionId, callId: Ids.ToolCallId): (tenantId: Ids.TenantId) => string;
+    (tenantId: Ids.TenantId, executionId: Ids.ExecutionId, callId: Ids.ToolCallId): string;
+};
 export interface RecordResultInput {
     readonly result: Tool.Result;
     readonly createdAt: number;
@@ -176,7 +179,7 @@ export interface Interface {
     readonly listAttempts: (callId: Ids.ToolCallId) => Effect.Effect<ReadonlyArray<ToolAttemptRecord>, ToolCallRepositoryError>;
     readonly failOpenForExecution: (input: FailOpenForExecutionInput) => Effect.Effect<ReadonlyArray<ToolCallRecord>, ToolCallNotFound | ToolCallRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ToolCallRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/tool/tool-call-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const ToolCallRow: Schema.Struct<{
@@ -190,43 +193,43 @@ export declare const ToolCallRow: Schema.Struct<{
     readonly state: Schema.String;
     readonly wait_id: Schema.NullishOr<Schema.String>;
     readonly idempotency_key: Schema.String;
-    readonly available_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly available_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
     readonly active_attempt_id: Schema.NullishOr<Schema.String>;
     readonly claim_owner: Schema.NullishOr<Schema.String>;
-    readonly claimed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
-    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
+    readonly claimed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
+    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
     readonly external_outcome_json: Schema.NullishOr<Schema.Unknown>;
-    readonly external_outcome_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
+    readonly external_outcome_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const ToolAttemptRow: Schema.Struct<{
     readonly id: Schema.String;
     readonly tool_call_id: Schema.String;
-    readonly attempt_number: Schema.Union<readonly [Schema.Number, Schema.String, Schema.BigInt]>;
+    readonly attempt_number: Schema.Union<readonly [Schema.Finite, Schema.String, Schema.BigInt]>;
     readonly state: Schema.String;
     readonly worker_id: Schema.NullishOr<Schema.String>;
-    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
+    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
     readonly error: Schema.NullishOr<Schema.String>;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly completed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly completed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
 }>;
 export declare const ToolResultRow: Schema.Struct<{
     readonly tool_call_id: Schema.String;
     readonly output_json: Schema.Unknown;
     readonly error: Schema.NullishOr<Schema.String>;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 type TestInterface = Pick<Interface, "recordCall" | "getCall" | "listCalls" | "recordResult" | "getResult"> & Partial<Interface>;
 export declare const testLayer: (implementation: TestInterface) => Layer.Layer<Service, never, never>;
-export declare const recordCall: (input: RecordCallInput) => Effect.Effect<ToolCallRecord, ToolCallRepositoryError | DuplicateToolCall, Service>;
+export declare const recordCall: (input: RecordCallInput) => Effect.Effect<ToolCallRecord, DuplicateToolCall | ToolCallRepositoryError, Service>;
 export declare const getCall: (id: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<ToolCallRecord | undefined, ToolCallRepositoryError, Service>;
 export declare const listCalls: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<readonly ToolCallRecord[], ToolCallRepositoryError, Service>;
-export declare const recordResult: (input: RecordResultInput) => Effect.Effect<ToolResultRecord, ToolCallRepositoryError | ToolCallNotFound | DuplicateToolResult, Service>;
+export declare const recordResult: (input: RecordResultInput) => Effect.Effect<ToolResultRecord, DuplicateToolResult | ToolCallNotFound | ToolCallRepositoryError, Service>;
 export declare const getResult: (callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<ToolResultRecord | undefined, ToolCallRepositoryError, Service>;
 export declare const ensureCall: (input: EnsureCallInput) => Effect.Effect<ToolCallRecord, ToolCallStateError, Service>;
 export declare const prepareExternalWait: (input: PrepareExternalWaitInput) => Effect.Effect<ToolCallRecord, ToolCallStateError, Service>;
@@ -236,5 +239,5 @@ export declare const claimRemote: (input: ClaimRemoteInput) => Effect.Effect<Too
 export declare const releaseRemote: (input: ReleaseRemoteInput) => Effect.Effect<ToolCallRecord, ToolCallStateError, Service>;
 export declare const acceptRemoteOutcome: (input: AcceptRemoteOutcomeInput) => Effect.Effect<AcceptedOutcome, ToolCallStateError, Service>;
 export declare const listAttempts: (callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<readonly ToolAttemptRecord[], ToolCallRepositoryError, Service>;
-export declare const failOpenForExecution: (input: FailOpenForExecutionInput) => Effect.Effect<readonly ToolCallRecord[], ToolCallRepositoryError | ToolCallNotFound, Service>;
+export declare const failOpenForExecution: (input: FailOpenForExecutionInput) => Effect.Effect<readonly ToolCallRecord[], ToolCallNotFound | ToolCallRepositoryError, Service>;
 export {};

package/dist/types/store-sql/topic/topic-repository.d.ts

@@ -32,7 +32,7 @@ export interface Interface {
     readonly remove: (input: RemoveInput) => Effect.Effect<void, TopicRepositoryError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<Subscription>, TopicRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/TopicRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/topic/topic-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, SqlClient>;

package/dist/types/store-sql/workflow/workflow-definition-repository.d.ts

@@ -1,31 +1,33 @@
 import { Ids, Workflow } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { SqlError } from "effect/unstable/sql/SqlError";
 declare const RepositoryError_base: Schema.Class<RepositoryError, Schema.TaggedStruct<"WorkflowDefinitionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class RepositoryError extends RepositoryError_base {
 }
+type RepositoryFailure = RepositoryError | SqlError;
 export interface Interface {
-    readonly register: (input: Workflow.RegisterDefinitionPayload) => Effect.Effect<Workflow.DefinitionRevisionRecord, unknown>;
-    readonly get: (id: Ids.WorkflowDefinitionId, revision?: Workflow.DefinitionRevision) => Effect.Effect<Workflow.DefinitionRevisionRecord | undefined, unknown>;
-    readonly list: (id: Ids.WorkflowDefinitionId) => Effect.Effect<ReadonlyArray<Workflow.DefinitionRevisionRecord>, unknown>;
-    readonly start: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, unknown>;
-    readonly inspect: (id: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, unknown>;
-    readonly listNonterminal: () => Effect.Effect<ReadonlyArray<Workflow.RunRecord>, unknown>;
-    readonly cancel: (id: Ids.ExecutionId) => Effect.Effect<TransitionResult, unknown>;
-    readonly getOperation: (executionId: Ids.ExecutionId, operationId: Ids.WorkflowOperationId) => Effect.Effect<Workflow.OperationState | undefined, unknown>;
-    readonly putOperation: (state: Workflow.OperationState) => Effect.Effect<Workflow.OperationState, unknown>;
-    readonly listOperations: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.OperationState>, unknown>;
-    readonly appendLifecycle: (event: Omit<Workflow.LifecycleEvent, "sequence">) => Effect.Effect<Workflow.LifecycleEvent, unknown>;
-    readonly listLifecycle: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.LifecycleEvent>, unknown>;
-    readonly finish: (id: Ids.ExecutionId, status: "completed" | "failed", data?: Workflow.LifecycleEvent["data"]) => Effect.Effect<TransitionResult, unknown>;
+    readonly register: (input: Workflow.RegisterDefinitionPayload) => Effect.Effect<Workflow.DefinitionRevisionRecord, RepositoryFailure>;
+    readonly get: (id: Ids.WorkflowDefinitionId, revision?: Workflow.DefinitionRevision) => Effect.Effect<Workflow.DefinitionRevisionRecord | undefined, RepositoryFailure>;
+    readonly list: (id: Ids.WorkflowDefinitionId) => Effect.Effect<ReadonlyArray<Workflow.DefinitionRevisionRecord>, RepositoryFailure>;
+    readonly start: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, RepositoryFailure>;
+    readonly inspect: (id: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, RepositoryFailure>;
+    readonly listNonterminal: (_?: never) => Effect.Effect<ReadonlyArray<Workflow.RunRecord>, RepositoryFailure>;
+    readonly cancel: (id: Ids.ExecutionId) => Effect.Effect<TransitionResult, RepositoryFailure>;
+    readonly getOperation: (executionId: Ids.ExecutionId, operationId: Ids.WorkflowOperationId) => Effect.Effect<Workflow.OperationState | undefined, RepositoryFailure>;
+    readonly putOperation: (state: Workflow.OperationState) => Effect.Effect<Workflow.OperationState, RepositoryFailure>;
+    readonly listOperations: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.OperationState>, RepositoryFailure>;
+    readonly appendLifecycle: (event: Omit<Workflow.LifecycleEvent, "sequence">) => Effect.Effect<Workflow.LifecycleEvent, RepositoryFailure>;
+    readonly listLifecycle: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.LifecycleEvent>, RepositoryFailure>;
+    readonly finish: (id: Ids.ExecutionId, status: "completed" | "failed", data?: Workflow.LifecycleEvent["data"]) => Effect.Effect<TransitionResult, RepositoryFailure>;
 }
 export interface TransitionResult {
     readonly transitioned: boolean;
     readonly record: Workflow.RunRecord | undefined;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/WorkflowDefinitionRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/workflow/workflow-definition-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const memoryLayer: Layer.Layer<Service, never, never>;

package/dist/types/store-sql/workspace/workspace-lease-repository.d.ts

@@ -70,7 +70,7 @@ export interface Interface {
     readonly markReleased: (input: MarkTerminalInput) => Effect.Effect<WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
     readonly markFailed: (input: MarkTerminalInput) => Effect.Effect<WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/WorkspaceLeaseRepository", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/workspace/workspace-lease-repository/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const WorkspaceLeaseRow: Schema.Struct<{
@@ -84,8 +84,8 @@ export declare const WorkspaceLeaseRow: Schema.Struct<{
     readonly region: Schema.NullishOr<Schema.String>;
     readonly request_json: Schema.NullishOr<Schema.Unknown>;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const WorkspaceSnapshotRow: Schema.Struct<{
     readonly id: Schema.String;
@@ -94,17 +94,17 @@ export declare const WorkspaceSnapshotRow: Schema.Struct<{
     readonly reason: Schema.String;
     readonly snapshot_ref: Schema.String;
     readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const plan: (input: PlanInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | DuplicateWorkspaceLease, Service>;
+export declare const plan: (input: PlanInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, DuplicateWorkspaceLease | WorkspaceLeaseRepositoryError, Service>;
 export declare const getByExecution: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceLeaseRepositoryError, Service>;
-export declare const markRunning: (input: MarkRunningInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
-export declare const markSuspended: (input: MarkSuspendedInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
-export declare const markResumed: (input: MarkResumedInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
-export declare const recordSnapshot: (input: RecordSnapshotInput) => Effect.Effect<Workspace.WorkspaceSnapshotRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
-export declare const markReleased: (input: MarkTerminalInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
-export declare const markFailed: (input: MarkTerminalInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
+export declare const markRunning: (input: MarkRunningInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError, Service>;
+export declare const markSuspended: (input: MarkSuspendedInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError, Service>;
+export declare const markResumed: (input: MarkResumedInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError, Service>;
+export declare const recordSnapshot: (input: RecordSnapshotInput) => Effect.Effect<Workspace.WorkspaceSnapshotRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError, Service>;
+export declare const markReleased: (input: MarkTerminalInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError, Service>;
+export declare const markFailed: (input: MarkTerminalInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError, Service>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/sdk",
-  "version": "0.2.15",
+  "version": "0.2.16",
   "description": "Effect-native durable execution SDK for addressable agents and tools",
   "type": "module",
   "exports": {
@@ -54,8 +54,8 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.4.3",
-    "@batonfx/providers": "0.4.3",
+    "@batonfx/core": "0.4.4",
+    "@batonfx/providers": "0.4.4",
     "@effect/ai-anthropic": "4.0.0-beta.93",
     "@effect/ai-openai": "4.0.0-beta.93",
     "@effect/ai-openai-compat": "4.0.0-beta.93",