@relayfx/sdk 0.3.0 → 0.3.2

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

@@ -1,14 +1,37 @@
-export * as AdapterOutbox from "./adapter-outbox";
-export * as Client from "./client";
-export * as Command from "./command";
-export * as Database from "./database";
-export * as Operation from "./operation";
-export * as ToolWorker from "./tool-worker";
-export * as Runtime from "./runtime";
-export { makeDatabaseIdentity, type DatabaseIdentity } from "./runtime";
-export { Address, Agent, Content, Entity, Envelope, Execution, Ids, Presence, Schedule, Shared, Skill, Tool, Waits, Workflow, } from "../schema/index";
-export { AddressBook, AddressResolution, AgentLoop, AgentRegistry, ActivityVersionRegistry, ArtifactStore, BlobStore, ChildRunService, ChildFanOutRuntime, EnvelopeService, EventLog, ExecutionEntity, ExecutionService, ExecutionWorkflow, EmbeddingModelService, LanguageModelService, ModelCallPolicy, PresenceService, PresenceTool, PromptAssembler, SchedulerService, SchemaRegistry, SkillRegistry, ToolRuntime, WaitService, WorkflowDefinitionRuntime, } from "../runtime/index";
-export { RunnerRuntime } from "../runtime/index";
-export { LanguageModelRegistration } from "../ai/index";
-export { RelaySchema, SkillDefinitionRepository } from "../store-sql/index";
-export declare const relayPackage = "@relayfx/sdk";
+import * as AdapterOutboxModule from "./adapter-outbox";
+import * as ClientModule from "./client-public";
+import * as ChildFanOutHostModule from "./child-fan-out-host";
+import * as CommandModule from "./command";
+import * as OperationModule from "./operation";
+import * as ToolWorkerModule from "./tool-worker";
+import * as RuntimeModule from "./runtime";
+import * as WorkflowDefinitionHostModule from "./workflow-definition-host";
+import { DatabaseIdentity, makeDatabaseIdentity } from "./database-identity";
+import { Address, Agent, ChildOrchestration, Content, Entity, Envelope, Execution, Ids, Inbox, Pagination, Presence, Schedule, Shared, Skill, State, Tool, Waits, Workflow } from "../schema/index";
+import * as ArtifactStoreModule from "../runtime/content/artifact-store-service";
+import * as BlobStoreModule from "../runtime/content/blob-store-service";
+import * as EmbeddingModelServiceModule from "../runtime/model/embedding-model-service";
+import * as LanguageModelServiceModule from "../runtime/model/language-model-service";
+import * as ModelHubModule from "../runtime/model/model-hub";
+import * as PromptAssemblerModule from "../runtime/agent/prompt-assembler-service";
+import * as SchemaRegistryModule from "../runtime/schema-registry/schema-registry-service";
+import * as ToolRuntimeModule from "./tool-runtime";
+import * as LanguageModelRegistrationModule from "./language-model-registration";
+export import AdapterOutbox = AdapterOutboxModule;
+export import Client = ClientModule;
+export import ChildFanOutHost = ChildFanOutHostModule;
+export import Command = CommandModule;
+export import Operation = OperationModule;
+export import ToolWorker = ToolWorkerModule;
+export import Runtime = RuntimeModule;
+export import WorkflowDefinitionHost = WorkflowDefinitionHostModule;
+export import ArtifactStore = ArtifactStoreModule;
+export import BlobStore = BlobStoreModule;
+export import EmbeddingModelService = EmbeddingModelServiceModule;
+export import LanguageModelService = LanguageModelServiceModule;
+export import ModelHub = ModelHubModule;
+export import PromptAssembler = PromptAssemblerModule;
+export import SchemaRegistry = SchemaRegistryModule;
+export import ToolRuntime = ToolRuntimeModule;
+export import LanguageModelRegistration = LanguageModelRegistrationModule;
+export { Address, Agent, ChildOrchestration, Content, DatabaseIdentity, Entity, Envelope, Execution, Ids, Inbox, Pagination, Presence, Schedule, Shared, Skill, State, Tool, Waits, Workflow, makeDatabaseIdentity, };

package/dist/types/relay/internal-client.d.ts

@@ -0,0 +1,22 @@
+import { Service as AddressBookService } from "../runtime/address/address-book-service";
+import { Service as AgentRegistryService } from "../runtime/agent/agent-registry-service";
+import { Service as EnvelopeServiceService } from "../runtime/envelope/envelope-service";
+import { Service as EntityInstanceServiceService } from "../runtime/entity/entity-instance-service";
+import { Service as EntityRegistryService } from "../runtime/entity/entity-registry-service";
+import { Service as EventLogService } from "../runtime/execution/event-log-service";
+import { Service as ExecutionServiceService } from "../runtime/execution/execution-service";
+import { Service as ExecutionWatchService } from "../runtime/execution/execution-watch-service";
+import { Service as SessionStreamService } from "../runtime/execution/session-stream-service";
+import { Service as PresenceServiceService } from "../runtime/presence/presence-contract";
+import { Service as SkillRegistryService } from "../runtime/skill/skill-registry-service";
+import { Service as ExecutionStateService } from "../runtime/state/execution-state-service";
+import { Service as ToolTransitionCoordinatorService } from "../runtime/tool/tool-transition-coordinator";
+import { Service as TopicServiceService } from "../runtime/topic/topic-service";
+import { Service as WaitServiceService } from "../runtime/wait/wait-service";
+import { ChildExecutionRepository, ChildFanOutRepository, ClusterRegistryRepository, EnvelopeRepository, ExecutionRepository, InboxRepository, ScheduleRepository, SessionRepository, SteeringRepository, ToolCallRepository, WorkflowDefinitionRepository } from "../store-sql/portable";
+import { Layer } from "effect";
+import { Sharding, ShardingConfig } from "effect/unstable/cluster";
+import { Service, type Interface } from "./client-public";
+export type RuntimeRequirements = AgentRegistryService | EntityRegistryService | EntityInstanceServiceService | AddressBookService | ExecutionServiceService | EnvelopeServiceService | WaitServiceService | EventLogService | SessionStreamService | ExecutionWatchService | ExecutionStateService | PresenceServiceService | EnvelopeRepository.Service | ExecutionRepository.Service | InboxRepository.Service | TopicServiceService | ToolCallRepository.Service | ChildExecutionRepository.Service | ChildFanOutRepository.Service | SessionRepository.Service | SteeringRepository.Service | ClusterRegistryRepository.Service | ScheduleRepository.Service | SkillRegistryService | ToolTransitionCoordinatorService | WorkflowDefinitionRepository.Service | Sharding.Sharding | ShardingConfig.ShardingConfig;
+export declare const layerFromRuntime: Layer.Layer<Service, never, RuntimeRequirements>;
+export declare const testLayer: (implementation: Omit<Interface, "registerWorkflowDefinition" | "getWorkflowDefinitionRevision" | "listWorkflowDefinitionRevisions" | "startWorkflowRun" | "inspectWorkflowRun" | "replayWorkflowRun" | "cancelWorkflowRun" | "streamSession" | "watchExecutions" | "getPresence" | "watchPresence" | "registerEntityKind" | "getOrCreateEntity" | "getEntity" | "destroyEntity" | "listEntities" | "followExecution" | "pageExecutionEvents"> & Partial<Interface>) => Layer.Layer<Service, never, never>;

package/dist/types/relay/language-model-registration.d.ts

@@ -0,0 +1,13 @@
+import { ModelRegistry } from "@batonfx/core";
+import type { Effect } from "effect";
+export type { AnthropicInput, WithAnthropicOptions } from "@batonfx/providers/anthropic";
+export { anthropic, anthropicClientLayerConfig, withAnthropic, withAnthropicFetch } from "@batonfx/providers/anthropic";
+export type { DeterministicInput, WithOpenAiOrDeterministicOptions } from "@batonfx/providers/deterministic";
+export { withDeterministic, withOpenAiOrDeterministic, withOpenAiOrDeterministicFetch, } from "@batonfx/providers/deterministic";
+export declare const deterministicModel: (input: import("@batonfx/providers/deterministic").DeterministicInput) => Effect.Effect<ModelRegistry.Registration>;
+export type { OpenAiAccountCredential, OpenAiAccountCredentials, OpenAiAccountInput, OpenAiInput, RegistrationOptions, WithOpenAiOptions, } from "@batonfx/providers/openai";
+export { openAi, openAiAccount, OpenAiAccountCredentialError, openAiClientLayerConfig, withOpenAi, withOpenAiAccount, withOpenAiAccountFetch, withOpenAiFetch, } from "@batonfx/providers/openai";
+export type { OpenAiCompatibleInput, WithOpenAiCompatibleOptions } from "@batonfx/providers/openai-compat";
+export { openAiCompatible, openAiCompatibleClientLayerConfig, withOpenAiCompatible, withOpenAiCompatibleFetch, } from "@batonfx/providers/openai-compat";
+export type { OpenRouterInput, WithOpenRouterOptions } from "@batonfx/providers/openrouter";
+export { openRouter, openRouterClientLayerConfig, withOpenRouter, withOpenRouterFetch, } from "@batonfx/providers/openrouter";

package/dist/types/relay/mysql.d.ts

@@ -1,13 +1,12 @@
-import { Effect, Layer } from "effect";
+import { Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { RuntimeMigrationError, type DatabaseIdentity, type DatabaseLayer, type RuntimeConfigurationError } from "./runtime";
-export interface MySQLRuntimeDatabaseOptions<E, R> {
+import { type AcquisitionError, RuntimeMigrationError, type DatabaseIdentity, type Database, type RuntimeConfigurationError } from "./runtime";
+interface MySQLRuntimeDatabaseOptions<E, R> {
     readonly clientLayer: Layer.Layer<SqlClient, E, R>;
     readonly databaseIdentity: DatabaseIdentity;
 }
-export declare const runtimeDatabaseLayer: <E, R>(options: MySQLRuntimeDatabaseOptions<E, R>) => DatabaseLayer<"mysql", RuntimeConfigurationError | RuntimeMigrationError, R>;
-export declare const migrate: <E, R>(options: MySQLRuntimeDatabaseOptions<E, R>) => Effect.Effect<void, RuntimeConfigurationError | RuntimeMigrationError, R>;
+declare const database: <E, R>(options: MySQLRuntimeDatabaseOptions<E, R>) => Database<"mysql", RuntimeConfigurationError | RuntimeMigrationError | Extract<E, AcquisitionError>, R>;
 export declare const MySQL: {
-    readonly runtimeDatabaseLayer: typeof runtimeDatabaseLayer;
-    readonly migrate: typeof migrate;
+    readonly database: typeof database;
 };
+export {};

package/dist/types/relay/operation.d.ts

@@ -644,7 +644,7 @@ export declare const FollowExecutionItem: Schema.Union<readonly [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<{
@@ -2392,7 +2392,7 @@ export declare const SessionStreamItem: Schema.Union<readonly [Schema.TaggedStru
         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<{
@@ -2703,7 +2703,7 @@ export declare const ReplayExecutionResult: 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<{
@@ -2785,7 +2785,7 @@ export declare const PageExecutionEventsResult: 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/relay/postgres.d.ts

@@ -1,13 +1,16 @@
-import { Effect, Layer } from "effect";
+import { Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { RuntimeMigrationError, type DatabaseIdentity, type DatabaseLayer, type RuntimeConfigurationError } from "./runtime";
-export interface PostgresRuntimeDatabaseOptions<E, R> {
+import { type AcquisitionError, RuntimeMigrationError, type DatabaseIdentity, type Database, type RuntimeConfigurationError } from "./runtime";
+interface PostgresRuntimeDatabaseOptions<E, R> {
     readonly clientLayer: Layer.Layer<SqlClient, E, R>;
     readonly databaseIdentity: DatabaseIdentity;
 }
-export declare const runtimeDatabaseLayer: <E, R>(options: PostgresRuntimeDatabaseOptions<E, R>) => DatabaseLayer<"pg", RuntimeConfigurationError | RuntimeMigrationError, R>;
-export declare const migrate: <E, R>(options: PostgresRuntimeDatabaseOptions<E, R>) => Effect.Effect<void, RuntimeConfigurationError | RuntimeMigrationError, R>;
+export interface PgTypeParsers {
+    readonly getTypeParser: (typeId: number, format?: "text" | "binary") => (value: string) => unknown;
+}
+declare const database: <E, R>(options: PostgresRuntimeDatabaseOptions<E, R>) => Database<"pg", RuntimeConfigurationError | RuntimeMigrationError | Extract<E, AcquisitionError>, R>;
 export declare const Postgres: {
-    readonly runtimeDatabaseLayer: typeof runtimeDatabaseLayer;
-    readonly migrate: typeof migrate;
+    readonly database: typeof database;
+    readonly pgTypeParsers: PgTypeParsers;
 };
+export {};

package/dist/types/relay/runtime-acquisition-error.d.ts

@@ -0,0 +1,61 @@
+import { Cause, Schema } from "effect";
+export declare const RuntimeConfigurationCategory: Schema.Literals<readonly ["missing-http-client", "provider-config", "model-registration", "tool-dependency", "database-config", "unknown-host-layer"]>;
+export type RuntimeConfigurationCategory = typeof RuntimeConfigurationCategory.Type;
+export declare const RuntimeConfigurationScope: Schema.Literals<readonly ["host-layer", "database-client"]>;
+export type RuntimeConfigurationScope = typeof RuntimeConfigurationScope.Type;
+declare const RuntimeHostLayerFailure_base: Schema.Class<RuntimeHostLayerFailure, Schema.TaggedStruct<"RuntimeHostLayerFailure", {
+    readonly category: Schema.Literals<readonly ["missing-http-client", "provider-config", "model-registration", "tool-dependency", "database-config", "unknown-host-layer"]>;
+}>, Cause.YieldableError>;
+export declare class RuntimeHostLayerFailure extends RuntimeHostLayerFailure_base {
+}
+export declare const SafeCauseReason: Schema.TaggedUnion<{
+    readonly Die: Schema.TaggedStruct<"Die", {
+        readonly defectTag: Schema.Literal<"UnknownDefect">;
+    }>;
+    readonly Fail: Schema.TaggedStruct<"Fail", {
+        readonly category: Schema.Literals<readonly ["missing-http-client", "provider-config", "model-registration", "tool-dependency", "database-config", "unknown-host-layer"]>;
+        readonly errorTag: Schema.Literals<readonly ["RuntimeHostLayerFailure", "UnknownTypedFailure"]>;
+    }>;
+    readonly Interrupt: Schema.TaggedStruct<"Interrupt", {}>;
+}>;
+export type SafeCauseReason = typeof SafeCauseReason.Type;
+export declare const SafeCause: Schema.Struct<{
+    readonly reasons: Schema.$Array<Schema.TaggedUnion<{
+        readonly Die: Schema.TaggedStruct<"Die", {
+            readonly defectTag: Schema.Literal<"UnknownDefect">;
+        }>;
+        readonly Fail: Schema.TaggedStruct<"Fail", {
+            readonly category: Schema.Literals<readonly ["missing-http-client", "provider-config", "model-registration", "tool-dependency", "database-config", "unknown-host-layer"]>;
+            readonly errorTag: Schema.Literals<readonly ["RuntimeHostLayerFailure", "UnknownTypedFailure"]>;
+        }>;
+        readonly Interrupt: Schema.TaggedStruct<"Interrupt", {}>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export type SafeCause = typeof SafeCause.Type;
+declare const RuntimeConfigurationError_base: Schema.Class<RuntimeConfigurationError, Schema.TaggedStruct<"RuntimeConfigurationError", {
+    readonly category: Schema.Literals<readonly ["missing-http-client", "provider-config", "model-registration", "tool-dependency", "database-config", "unknown-host-layer"]>;
+    readonly scope: Schema.Literals<readonly ["host-layer", "database-client"]>;
+    readonly cause: Schema.Struct<{
+        readonly reasons: Schema.$Array<Schema.TaggedUnion<{
+            readonly Die: Schema.TaggedStruct<"Die", {
+                readonly defectTag: Schema.Literal<"UnknownDefect">;
+            }>;
+            readonly Fail: Schema.TaggedStruct<"Fail", {
+                readonly category: Schema.Literals<readonly ["missing-http-client", "provider-config", "model-registration", "tool-dependency", "database-config", "unknown-host-layer"]>;
+                readonly errorTag: Schema.Literals<readonly ["RuntimeHostLayerFailure", "UnknownTypedFailure"]>;
+            }>;
+            readonly Interrupt: Schema.TaggedStruct<"Interrupt", {}>;
+        }>>;
+        readonly truncated: Schema.Boolean;
+    }>;
+}>, Cause.YieldableError>;
+export declare class RuntimeConfigurationError extends RuntimeConfigurationError_base {
+}
+export declare const safeCause: <E>(cause: Cause.Cause<E>) => SafeCause;
+export declare const normalizeAcquisitionCause: {
+    <E, P extends E = never>(cause: Cause.Cause<E>, scope: RuntimeConfigurationScope, preserve?: (error: E) => error is P): Cause.Cause<RuntimeConfigurationError | P>;
+    (scope: RuntimeConfigurationScope): <E>(cause: Cause.Cause<E>) => Cause.Cause<RuntimeConfigurationError>;
+};
+export declare const renderConfigurationError: (error: RuntimeConfigurationError) => string;
+export {};

package/dist/types/relay/runtime-database-adapter.d.ts

@@ -1,12 +1,15 @@
 import { Effect, Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { RuntimeConfigurationError, RuntimeMigrationError, type DatabaseIdentity, type DatabaseLayer, type Dialect } from "./runtime";
-export declare const normalizeClientLayer: <E, R>(clientLayer: Layer.Layer<SqlClient, E, R>) => Layer.Layer<SqlClient, RuntimeConfigurationError, R>;
-export declare const runtimeDatabaseLayer: <D extends Dialect, E, R>(options: {
+import type { Database } from "./runtime-database-public";
+import { RuntimeConfigurationError, RuntimeMigrationError, type AcquisitionError, type DatabaseIdentity, type Dialect } from "./runtime";
+export declare const normalizeClientLayer: <E, R>(clientLayer: Layer.Layer<SqlClient, E, R>) => Layer.Layer<SqlClient, RuntimeConfigurationError | Extract<E, AcquisitionError>, R>;
+export declare const database: <D extends Dialect, E, R>(options: {
     readonly dialect: D;
     readonly clientLayer: Layer.Layer<SqlClient, E, R>;
     readonly databaseIdentity: DatabaseIdentity;
     readonly ownership: "runtime-exclusive" | "shared-multi-node";
     readonly schemaHead: string;
-    readonly schema: Effect.Effect<void, RuntimeMigrationError, SqlClient>;
-}) => DatabaseLayer<D, RuntimeConfigurationError | RuntimeMigrationError, R>;
+    readonly acquire: Effect.Effect<void, RuntimeMigrationError, SqlClient>;
+    readonly verify: Effect.Effect<void, RuntimeMigrationError, SqlClient>;
+    readonly migrate: Effect.Effect<void, RuntimeMigrationError, SqlClient>;
+}) => Database<D, RuntimeConfigurationError | RuntimeMigrationError | Extract<E, AcquisitionError>, R>;

package/dist/types/relay/runtime-database-owner.d.ts

@@ -0,0 +1,13 @@
+import { Effect, Layer } from "effect";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { Service as RuntimeDatabaseService } from "./runtime-database";
+import type { Dialect } from "./runtime";
+import type { Database } from "./runtime-database-public";
+import { RuntimeConfigurationError } from "./runtime-acquisition-error";
+export declare const make: <D extends Dialect, E, R>(value: {
+    readonly dialect: D;
+    readonly migrate: Effect.Effect<void, E, R>;
+    readonly verify: Effect.Effect<void, E, R>;
+    readonly runtimeLayer: Layer.Layer<RuntimeDatabaseService | SqlClient, E, R>;
+}) => Database<D, E, R>;
+export declare const runtimeLayer: <D extends Dialect, E, R>(database: Database<D, E, R>) => Layer.Layer<RuntimeDatabaseService | SqlClient, E | RuntimeConfigurationError, R>;

package/dist/types/relay/runtime-database-public.d.ts

@@ -0,0 +1,10 @@
+import type { Effect } from "effect";
+import type { Dialect } from "./runtime";
+declare const DatabaseTypeId: unique symbol;
+export interface Database<D extends Dialect, E = never, R = never> {
+    readonly [DatabaseTypeId]: D;
+    readonly dialect: D;
+    readonly migrate: Effect.Effect<void, E, R>;
+    readonly verify: Effect.Effect<void, E, R>;
+}
+export {};

package/dist/types/relay/runtime.d.ts

@@ -1,33 +1,26 @@
-import { ArtifactStore, BlobStore, ChildFanOutRuntime, EmbeddingModelService, LanguageModelService, PromptAssembler, RunnerRuntime, SchemaRegistry, ToolRuntime, WorkflowDefinitionRuntime } from "../runtime/index";
+import { Service as PromptAssemblerService } from "../runtime/agent/prompt-assembler-service";
+import { Service as ArtifactStoreService } from "../runtime/content/artifact-store-service";
+import { Service as BlobStoreService } from "../runtime/content/blob-store-service";
+import { Service as EmbeddingModelServiceService } from "../runtime/model/embedding-model-service";
+import { Service as LanguageModelServiceService } from "../runtime/model/language-model-service";
+import { Service as SchemaRegistryService } from "../runtime/schema-registry/schema-registry-service";
 import { Cause, Context, Effect, Layer, Schema } from "effect";
 import type { Duration } from "effect";
 import type { HttpServer } from "effect/unstable/http/HttpServer";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { Service as ClientService, type RuntimeRequirements as ClientRuntimeRequirements } from "./client";
-import { Service as RuntimeDatabaseService } from "./runtime-database";
+export { RuntimeConfigurationCategory, RuntimeConfigurationError, RuntimeConfigurationScope, RuntimeHostLayerFailure, SafeCause, SafeCauseReason, normalizeAcquisitionCause, renderConfigurationError, safeCause, } from "./runtime-acquisition-error";
+import { RuntimeConfigurationError } from "./runtime-acquisition-error";
+import { Service as ClientService } from "./client-public";
+export { DatabaseIdentity, makeDatabaseIdentity } from "./database-identity";
+import { Service as ChildFanOutHostService } from "./child-fan-out-host";
+import { Service as WorkflowDefinitionHostService } from "./workflow-definition-host";
+import type { Database } from "./runtime-database-public";
+import type { ClientIdentifier, PresenceIdentifier } from "./http-server";
+import type { Service as RuntimePresenceService } from "../runtime/presence/presence-contract";
+import { HostService as ToolRuntimeHostService } from "./tool-runtime";
 export { RuntimeCapabilityUnavailable } from "./runtime-capability-policy";
-export * as RuntimeDatabase from "./runtime-database";
-export declare const DatabaseIdentity: Schema.brand<Schema.NonEmptyString, "@relayfx/sdk/DatabaseIdentity">;
-export type DatabaseIdentity = typeof DatabaseIdentity.Type;
-export declare const makeDatabaseIdentity: (input: unknown) => DatabaseIdentity;
+export type { Database } from "./runtime-database-public";
 export declare const Dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
 export type Dialect = typeof Dialect.Type;
-export declare const DatabaseDialect: unique symbol;
-export type DatabaseLayer<D extends Dialect, E = never, R = never> = Layer.Layer<RuntimeDatabaseService | SqlClient, E, R> & {
-    readonly [DatabaseDialect]: D;
-};
-declare const HostLayerError_base: Schema.Class<HostLayerError, Schema.TaggedStruct<"HostLayerError", {
-    readonly service: Schema.String;
-    readonly reason: Schema.String;
-}>, Cause.YieldableError>;
-export declare class HostLayerError extends HostLayerError_base {
-}
-declare const ConfigFailure_base: Schema.Class<ConfigFailure, Schema.TaggedStruct<"ConfigFailure", {
-    readonly reason: Schema.String;
-}>, Cause.YieldableError>;
-export declare class ConfigFailure extends ConfigFailure_base {
-    readonly originalCause?: unknown;
-}
 declare const NotificationFailure_base: Schema.Class<NotificationFailure, Schema.TaggedStruct<"NotificationFailure", {
     readonly reason: Schema.String;
 }>, Cause.YieldableError>;
@@ -82,21 +75,12 @@ declare const HostUnavailable_base: Schema.Class<HostUnavailable, Schema.TaggedS
 }>, Cause.YieldableError>;
 export declare class HostUnavailable extends HostUnavailable_base {
 }
-export type RuntimeConfigurationCause = ConfigFailure | HostLayerError;
 export type RuntimeTopologyCause = ClusterFailure | DatabaseDialectMismatch | DatabaseAlreadyOwned | UnsupportedTopology;
 export type RuntimeMigrationCause = SqlFailure | MigratorError | SchemaHeadMismatch;
 export type RuntimeReadinessCause = SqlFailure | NotificationFailure | ClusterFailure | HostUnavailable;
-export declare const RuntimeConfigurationCause: Schema.Schema<RuntimeConfigurationCause>;
 export declare const RuntimeTopologyCause: Schema.Schema<RuntimeTopologyCause>;
 export declare const RuntimeMigrationCause: Schema.Schema<RuntimeMigrationCause>;
 export declare const RuntimeReadinessCause: Schema.Schema<RuntimeReadinessCause>;
-declare const RuntimeConfigurationError_base: Schema.Class<RuntimeConfigurationError, Schema.TaggedStruct<"RuntimeConfigurationError", {
-    readonly setting: Schema.String;
-    readonly nextAction: Schema.Literals<readonly ["provide-setting", "provide-host-layer"]>;
-    readonly cause: Schema.Schema<RuntimeConfigurationCause>;
-}>, Cause.YieldableError>;
-export declare class RuntimeConfigurationError extends RuntimeConfigurationError_base {
-}
 declare const RuntimeTopologyError_base: Schema.Class<RuntimeTopologyError, Schema.TaggedStruct<"RuntimeTopologyError", {
     readonly dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
     readonly role: Schema.Literals<readonly ["embedded", "runner", "client"]>;
@@ -120,26 +104,45 @@ declare const RuntimeReadinessError_base: Schema.Class<RuntimeReadinessError, Sc
 export declare class RuntimeReadinessError extends RuntimeReadinessError_base {
 }
 export type AcquisitionError = RuntimeConfigurationError | RuntimeTopologyError | RuntimeMigrationError;
-export type RuntimeCapabilityStatus = {
-    readonly enabled: false;
-    readonly source: "local-host" | "role-unavailable";
-    readonly health: "not-applicable";
-} | {
-    readonly enabled: true;
-    readonly source: "local-host";
-    readonly health: "healthy" | "unhealthy";
-};
-export interface ReadinessStatus {
-    readonly ready: true;
-    readonly role: "embedded" | "runner" | "client";
-    readonly dialect: Dialect;
-    readonly databaseIdentity: DatabaseIdentity;
-    readonly schemaHead: string;
-    readonly notification: "pg-listen-notify" | "polling" | "in-process";
-    readonly capabilities: {
-        readonly fanOut: RuntimeCapabilityStatus;
-        readonly workflowDefinition: RuntimeCapabilityStatus;
-    };
+export declare const RuntimeCapabilityStatus: Schema.Union<readonly [Schema.Struct<{
+    readonly enabled: Schema.Literal<false>;
+    readonly source: Schema.Literals<readonly ["local-host", "role-unavailable"]>;
+    readonly health: Schema.Literal<"not-applicable">;
+}>, Schema.Struct<{
+    readonly enabled: Schema.Literal<true>;
+    readonly source: Schema.Literal<"local-host">;
+    readonly health: Schema.Literals<readonly ["healthy", "unhealthy"]>;
+}>]>;
+export type RuntimeCapabilityStatus = typeof RuntimeCapabilityStatus.Type;
+export declare const ReadinessStatus: Schema.Struct<{
+    readonly ready: Schema.Literal<true>;
+    readonly role: Schema.Literals<readonly ["embedded", "runner", "client"]>;
+    readonly dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
+    readonly databaseIdentity: Schema.brand<Schema.NonEmptyString, "@relayfx/sdk/DatabaseIdentity">;
+    readonly schemaHead: Schema.String;
+    readonly notification: Schema.Literals<readonly ["pg-listen-notify", "polling", "in-process"]>;
+    readonly capabilities: Schema.Struct<{
+        readonly fanOut: Schema.Union<readonly [Schema.Struct<{
+            readonly enabled: Schema.Literal<false>;
+            readonly source: Schema.Literals<readonly ["local-host", "role-unavailable"]>;
+            readonly health: Schema.Literal<"not-applicable">;
+        }>, Schema.Struct<{
+            readonly enabled: Schema.Literal<true>;
+            readonly source: Schema.Literal<"local-host">;
+            readonly health: Schema.Literals<readonly ["healthy", "unhealthy"]>;
+        }>]>;
+        readonly workflowDefinition: Schema.Union<readonly [Schema.Struct<{
+            readonly enabled: Schema.Literal<false>;
+            readonly source: Schema.Literals<readonly ["local-host", "role-unavailable"]>;
+            readonly health: Schema.Literal<"not-applicable">;
+        }>, Schema.Struct<{
+            readonly enabled: Schema.Literal<true>;
+            readonly source: Schema.Literal<"local-host">;
+            readonly health: Schema.Literals<readonly ["healthy", "unhealthy"]>;
+        }>]>;
+    }>;
+}>;
+export interface ReadinessStatus extends Schema.Schema.Type<typeof ReadinessStatus> {
 }
 export interface Interface {
     readonly readiness: Effect.Effect<ReadinessStatus, RuntimeReadinessError>;
@@ -164,35 +167,37 @@ export interface ClusterClientOptions {
     readonly shardLockExpiration?: Duration.Input;
     readonly shardLockDisableAdvisory?: boolean;
 }
-export type MultiNodeDatabaseLayer<E = never, R = never> = DatabaseLayer<"pg", E, R> | DatabaseLayer<"mysql", E, R>;
+export type MultiNodeDatabase<E = never, R = never> = Database<"pg", E, R> | Database<"mysql", E, R>;
 type HostOptions<HostE, HostR, ToolE = HostE, ToolR = HostR> = {
-    readonly languageModelLayer: Layer.Layer<LanguageModelService.Service, HostE, HostR>;
-    readonly toolRuntimeLayer: Layer.Layer<ToolRuntime.Service, ToolE, ToolR>;
-    readonly embeddingModelLayer?: Layer.Layer<EmbeddingModelService.Service, HostE, HostR>;
-    readonly blobStoreLayer?: Layer.Layer<BlobStore.Service, HostE, HostR>;
-    readonly artifactStoreLayer?: Layer.Layer<ArtifactStore.Service, HostE, HostR>;
-    readonly promptAssemblerLayer?: Layer.Layer<PromptAssembler.Service, HostE, HostR>;
-    readonly schemaRegistryLayer?: Layer.Layer<SchemaRegistry.Service, HostE, HostR>;
+    readonly languageModelLayer: Layer.Layer<LanguageModelServiceService, HostE, HostR>;
+    readonly toolRuntimeLayer: Layer.Layer<ToolRuntimeHostService, ToolE, ToolR>;
+    readonly embeddingModelLayer?: Layer.Layer<EmbeddingModelServiceService, HostE, HostR>;
+    readonly blobStoreLayer?: Layer.Layer<BlobStoreService, HostE, HostR>;
+    readonly artifactStoreLayer?: Layer.Layer<ArtifactStoreService, HostE, HostR>;
+    readonly promptAssemblerLayer?: Layer.Layer<PromptAssemblerService, HostE, HostR>;
+    readonly schemaRegistryLayer?: Layer.Layer<SchemaRegistryService, HostE, HostR>;
 };
 type EmbeddedHostOptions<HostE, HostR, ChildE, ChildR, WorkflowE, WorkflowR, ToolE, ToolR> = HostOptions<HostE, HostR, ToolE, ToolR> & {
-    readonly childFanOutHandlersLayer?: Layer.Layer<ChildFanOutRuntime.HandlerService, ChildE, ChildR>;
-    readonly workflowDefinitionHandlersLayer?: Layer.Layer<WorkflowDefinitionRuntime.HandlerService, WorkflowE, WorkflowR>;
+    readonly childFanOutHostLayer?: Layer.Layer<ChildFanOutHostService, ChildE, ChildR>;
+    readonly workflowDefinitionHostLayer?: Layer.Layer<WorkflowDefinitionHostService, WorkflowE, WorkflowR>;
 };
 export interface RunnerOptions<DBE, DBR, HostE, HostR> extends HostOptions<HostE, HostR> {
-    readonly databaseLayer: MultiNodeDatabaseLayer<DBE, DBR>;
+    readonly database: MultiNodeDatabase<DBE, DBR>;
     readonly cluster: ClusterHttpOptions;
 }
 export interface ClientOptions<DBE, DBR> {
-    readonly databaseLayer: MultiNodeDatabaseLayer<DBE, DBR>;
+    readonly database: MultiNodeDatabase<DBE, DBR>;
     readonly cluster?: ClusterClientOptions;
 }
-export type EmbeddedOutput = Service | ClientService;
-export type RunnerOutput = Service | ClientService;
-export type ClientOutput = Service | ClientService;
+type PublicServiceOutput = ClientService | ClientIdentifier | RuntimePresenceService | PresenceIdentifier;
+type ExecutionStateIdentifier = "@relayfx/runtime/state/execution-state-service/Service";
+export type EmbeddedOutput = Service | PublicServiceOutput | ExecutionStateIdentifier;
+export type RunnerOutput = Service | PublicServiceOutput | ExecutionStateIdentifier;
+export type ClientOutput = Service | PublicServiceOutput | ExecutionStateIdentifier;
 export declare function layerEmbedded<D extends Dialect, DBE, DBR, HostE, HostR, ChildE = never, ChildR = never, WorkflowE = never, WorkflowR = never, ToolE = never, ToolR = never>(options: EmbeddedHostOptions<HostE, HostR, ChildE, ChildR, WorkflowE, WorkflowR, ToolE, ToolR> & {
-    readonly databaseLayer: DatabaseLayer<D, DBE, DBR>;
-}): Layer.Layer<EmbeddedOutput, AcquisitionError, DBR | HostR | ToolR | Exclude<ChildR, RunnerRuntime.Service | ClientRuntimeRequirements> | Exclude<WorkflowR, RunnerRuntime.Service | ChildFanOutRuntime.Service | ClientRuntimeRequirements>>;
+    readonly database: Database<D, DBE, DBR>;
+}): Layer.Layer<EmbeddedOutput, AcquisitionError, DBR | HostR | ToolR | ChildR | WorkflowR>;
 export declare const layerRunner: <DBE, DBR, HostE, HostR, ToolE, ToolR>(options: Omit<RunnerOptions<DBE, DBR, HostE, HostR>, "toolRuntimeLayer"> & {
-    readonly toolRuntimeLayer: Layer.Layer<ToolRuntime.Service, ToolE, ToolR>;
-}) => Layer.Layer<RunnerOutput, AcquisitionError, DBR | HostR | ToolR | HttpServer>;
+    readonly toolRuntimeLayer: Layer.Layer<ToolRuntimeHostService, ToolE, ToolR>;
+}) => Layer.Layer<RunnerOutput, AcquisitionError, DBR | HttpServer | HostR | ToolR>;
 export declare const layerClient: <DBE, DBR>(options: ClientOptions<DBE, DBR>) => Layer.Layer<ClientOutput, AcquisitionError, DBR>;

package/dist/types/relay/sqlite-runtime.d.ts

@@ -1,24 +1,11 @@
-import { type SqliteClientConfig } from "@effect/sql-sqlite-bun/SqliteClient";
-import { ChildFanOutRuntime, WorkflowDefinitionRuntime } from "../runtime/index";
-import { Layer } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { RuntimeConfigurationError, RuntimeMigrationError, RuntimeTopologyError, type DatabaseLayer } from "./runtime";
-export declare const clientLayer: (options: SqliteClientConfig) => Layer.Layer<SqlClient | import("@effect/sql-sqlite-bun/SqliteClient").SqliteClient, never, never>;
-export interface SQLiteRuntimeDatabaseOptions {
+import type { Database } from "./runtime-database-public";
+import { RuntimeConfigurationError, RuntimeMigrationError, RuntimeTopologyError } from "./runtime";
+interface SQLiteRuntimeDatabaseOptions {
     readonly filename: string;
     readonly disableWAL?: boolean;
     readonly spanAttributes?: Record<string, unknown>;
     readonly transformResultNames?: (name: string) => string;
     readonly transformQueryNames?: (name: string) => string;
 }
-export declare const runtimeDatabaseLayer: (options: SQLiteRuntimeDatabaseOptions) => DatabaseLayer<"sqlite", RuntimeConfigurationError | RuntimeTopologyError | RuntimeMigrationError>;
-export declare const migrationsLayer: Layer.Layer<never, import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, SqlClient>;
-export declare const layer: (options: SqliteClientConfig) => Layer.Layer<SqlClient, import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError | import("effect/unstable/sql/SqlError").SqlError, never>;
-export declare const workflowLayer: {
-    <E, R>(handlersLayer: Layer.Layer<WorkflowDefinitionRuntime.HandlerService, E, R>): (options: SqliteClientConfig) => ReturnType<typeof workflowLayer<E, R>>;
-    <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<WorkflowDefinitionRuntime.HandlerService, E, R>): Layer.Layer<WorkflowDefinitionRuntime.Service, unknown, R>;
-};
-export declare const childFanOutLayer: {
-    <E, R>(handlersLayer: Layer.Layer<ChildFanOutRuntime.HandlerService, E, R>): (options: SqliteClientConfig) => Layer.Layer<ChildFanOutRuntime.Service, unknown, R>;
-    <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<ChildFanOutRuntime.HandlerService, E, R>): Layer.Layer<ChildFanOutRuntime.Service, unknown, R>;
-};
+export declare const database: (options: SQLiteRuntimeDatabaseOptions) => Database<"sqlite", RuntimeConfigurationError | RuntimeTopologyError | RuntimeMigrationError>;
+export {};

package/dist/types/relay/sqlite.d.ts

@@ -1,31 +1,4 @@
-export * as Client from "./client";
-export * as Operation from "./operation";
-export * as SQLite from "./sqlite-runtime";
-export * as Runtime from "./runtime";
-export { Address, Agent, Content, Entity, Envelope, Execution, Ids, Schedule, Shared, Skill, Tool, Workflow, } from "../schema/index";
-export * as AddressBook from "../runtime/address/address-book-service";
-export * as AddressResolution from "../runtime/address/address-resolution-service";
-export * as AgentLoop from "../runtime/agent/agent-loop-service";
-export * as AgentRegistry from "../runtime/agent/agent-registry-service";
-export * as ActivityVersionRegistry from "../runtime/workflow/activity-version-registry";
-export * as ArtifactStore from "../runtime/content/artifact-store-service";
-export * as BlobStore from "../runtime/content/blob-store-service";
-export * as ChildRunService from "../runtime/child/child-run-service";
-export * as ChildFanOutRuntime from "../runtime/child/child-fan-out-runtime";
-export * as EnvelopeService from "../runtime/envelope/envelope-service";
-export * as EventLog from "../runtime/execution/event-log-service";
-export * as ExecutionEntity from "../runtime/cluster/execution-entity";
-export * as ExecutionService from "../runtime/execution/execution-service";
-export * as ExecutionWorkflow from "../runtime/workflow/execution-workflow";
-export * as EmbeddingModelService from "../runtime/model/embedding-model-service";
-export * as LanguageModelService from "../runtime/model/language-model-service";
-export * as ModelCallPolicy from "../runtime/model/model-call-policy";
-export * as PromptAssembler from "../runtime/agent/prompt-assembler-service";
-export * as RunnerRuntime from "../runtime/runner/runner-runtime-service";
-export * as SchedulerService from "../runtime/schedule/scheduler-service";
-export * as SchemaRegistry from "../runtime/schema-registry/schema-registry-service";
-export * as SkillRegistry from "../runtime/skill/skill-registry-service";
-export * as ToolRuntime from "../runtime/tool/tool-runtime-service";
-export * as WaitService from "../runtime/wait/wait-service";
-export * as WorkflowDefinitionRuntime from "../runtime/workflow/definition-runtime";
-export declare const relaySqlitePackage = "@relayfx/sdk/sqlite";
+import { database } from "./sqlite-runtime";
+export declare const SQLite: {
+    readonly database: typeof database;
+};

package/dist/types/relay/state-version-conflict.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from "effect";
+declare const StateVersionConflict_base: Schema.Class<StateVersionConflict, Schema.TaggedStruct<"StateVersionConflict", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly key: Schema.String;
+    readonly expected_version: Schema.Int;
+    readonly actual_version: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class StateVersionConflict extends StateVersionConflict_base {
+}
+export {};