@relayfx/sdk 0.2.13 → 0.2.14

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

@@ -0,0 +1,198 @@
+import { ArtifactStore, BlobStore, ChildFanOutRuntime, EmbeddingModelService, LanguageModelService, PromptAssembler, RunnerRuntime, SchemaRegistry, ToolRuntime, WorkflowDefinitionRuntime } from "../runtime/index";
+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 { 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, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"@relayfx/sdk/DatabaseIdentity">;
+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>;
+export declare class NotificationFailure extends NotificationFailure_base {
+    readonly originalCause?: unknown;
+}
+declare const ClusterFailure_base: Schema.Class<ClusterFailure, Schema.TaggedStruct<"ClusterFailure", {
+    readonly reason: Schema.String;
+}>, Cause.YieldableError>;
+export declare class ClusterFailure extends ClusterFailure_base {
+    readonly originalCause?: unknown;
+}
+declare const SqlFailure_base: Schema.Class<SqlFailure, Schema.TaggedStruct<"SqlFailure", {
+    readonly category: Schema.Literals<readonly ["connection", "statement", "unknown"]>;
+    readonly operation: Schema.Literals<readonly ["acquire", "migrate", "verify", "notify", "readiness"]>;
+    readonly retryable: Schema.Boolean;
+}>, Cause.YieldableError>;
+export declare class SqlFailure extends SqlFailure_base {
+    readonly originalCause?: unknown;
+}
+export declare const SqlDialect: Schema.Literals<readonly ["sqlite", "pg", "mysql", "mssql", "clickhouse"]>;
+declare const DatabaseDialectMismatch_base: Schema.Class<DatabaseDialectMismatch, Schema.TaggedStruct<"DatabaseDialectMismatch", {
+    readonly expected: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
+    readonly actual: Schema.Literals<readonly ["sqlite", "pg", "mysql", "mssql", "clickhouse"]>;
+}>, Cause.YieldableError>;
+export declare class DatabaseDialectMismatch extends DatabaseDialectMismatch_base {
+}
+declare const DatabaseAlreadyOwned_base: Schema.Class<DatabaseAlreadyOwned, Schema.TaggedStruct<"DatabaseAlreadyOwned", {
+    readonly databaseIdentity: Schema.brand<Schema.NonEmptyString, "@relayfx/sdk/DatabaseIdentity">;
+}>, Cause.YieldableError>;
+export declare class DatabaseAlreadyOwned extends DatabaseAlreadyOwned_base {
+}
+declare const UnsupportedTopology_base: Schema.Class<UnsupportedTopology, Schema.TaggedStruct<"UnsupportedTopology", {
+    readonly reason: Schema.String;
+}>, Cause.YieldableError>;
+export declare class UnsupportedTopology extends UnsupportedTopology_base {
+}
+declare const MigratorError_base: Schema.Class<MigratorError, Schema.TaggedStruct<"MigratorError", {
+    readonly reason: Schema.String;
+}>, Cause.YieldableError>;
+export declare class MigratorError extends MigratorError_base {
+}
+declare const SchemaHeadMismatch_base: Schema.Class<SchemaHeadMismatch, Schema.TaggedStruct<"SchemaHeadMismatch", {
+    readonly expected: Schema.String;
+    readonly actual: Schema.String;
+}>, Cause.YieldableError>;
+export declare class SchemaHeadMismatch extends SchemaHeadMismatch_base {
+}
+declare const HostUnavailable_base: Schema.Class<HostUnavailable, Schema.TaggedStruct<"HostUnavailable", {
+    readonly host: Schema.String;
+    readonly reason: Schema.String;
+}>, 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"]>;
+    readonly nextAction: Schema.Literals<readonly ["use-embedded", "use-postgres-or-mysql", "use-client-constructor", "reuse-runtime", "use-different-database"]>;
+    readonly cause: Schema.Schema<RuntimeTopologyCause>;
+}>, Cause.YieldableError>;
+export declare class RuntimeTopologyError extends RuntimeTopologyError_base {
+}
+declare const RuntimeMigrationError_base: Schema.Class<RuntimeMigrationError, Schema.TaggedStruct<"RuntimeMigrationError", {
+    readonly dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
+    readonly phase: Schema.Literals<readonly ["apply", "verify"]>;
+    readonly nextAction: Schema.Literals<readonly ["retry", "inspect-schema", "run-compatible-release"]>;
+    readonly cause: Schema.Schema<RuntimeMigrationCause>;
+}>, Cause.YieldableError>;
+export declare class RuntimeMigrationError extends RuntimeMigrationError_base {
+}
+declare const RuntimeReadinessError_base: Schema.Class<RuntimeReadinessError, Schema.TaggedStruct<"RuntimeReadinessError", {
+    readonly phase: Schema.Literals<readonly ["database", "notification", "cluster", "hosts"]>;
+    readonly cause: Schema.Schema<RuntimeReadinessCause>;
+}>, Cause.YieldableError>;
+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 interface Interface {
+    readonly readiness: Effect.Effect<ReadinessStatus, RuntimeReadinessError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/Runtime", Interface>;
+export declare class Service extends Service_base {
+}
+export interface ClusterHttpOptions {
+    readonly runnerHost: string;
+    readonly rpcPort: number;
+    readonly assignedShardGroups: ReadonlyArray<string>;
+    readonly availableShardGroups?: ReadonlyArray<string>;
+    readonly shardsPerGroup?: number;
+    readonly shardLockRefreshInterval?: Duration.Input;
+    readonly shardLockExpiration?: Duration.Input;
+    readonly shardLockDisableAdvisory?: boolean;
+}
+export interface ClusterClientOptions {
+    readonly availableShardGroups?: ReadonlyArray<string>;
+    readonly shardsPerGroup?: number;
+    readonly shardLockRefreshInterval?: Duration.Input;
+    readonly shardLockExpiration?: Duration.Input;
+    readonly shardLockDisableAdvisory?: boolean;
+}
+export type MultiNodeDatabaseLayer<E = never, R = never> = DatabaseLayer<"pg", E, R> | DatabaseLayer<"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>;
+};
+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>;
+};
+export interface RunnerOptions<DBE, DBR, HostE, HostR> extends HostOptions<HostE, HostR> {
+    readonly databaseLayer: MultiNodeDatabaseLayer<DBE, DBR>;
+    readonly cluster: ClusterHttpOptions;
+}
+export interface ClientOptions<DBE, DBR> {
+    readonly databaseLayer: MultiNodeDatabaseLayer<DBE, DBR>;
+    readonly cluster?: ClusterClientOptions;
+}
+export type EmbeddedOutput = Service | ClientService;
+export type RunnerOutput = Service | ClientService;
+export type ClientOutput = Service | ClientService;
+export declare const 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>>;
+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>;
+export declare const layerClient: <DBE, DBR>(options: ClientOptions<DBE, DBR>) => Layer.Layer<ClientOutput, AcquisitionError, DBR>;

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

@@ -3,7 +3,16 @@ import { ChildFanOutRuntime, WorkflowDefinitionRuntime } from "../runtime/index"
 import { WorkflowDefinitionRepository } from "../store-sql/portable";
 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 {
+    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/unstable/sql/SqlError").SqlError | import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError, SqlClient>;
 export declare const layer: (options: SqliteClientConfig) => Layer.Layer<SqlClient, import("effect/unstable/sql/SqlError").SqlError | import("@effect/sql-sqlite-bun/SqliteMigrator").MigrationError, never>;
 export declare const workflowLayer: <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<WorkflowDefinitionRuntime.HandlerService, E, R>) => Layer.Layer<SqlClient | WorkflowDefinitionRepository.Service | WorkflowDefinitionRuntime.HandlerService | WorkflowDefinitionRuntime.Service, unknown, Exclude<R, SqlClient | WorkflowDefinitionRepository.Service>>;

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

@@ -1,6 +1,7 @@
 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";
@@ -16,6 +17,7 @@ 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";

package/dist/types/runtime/child/child-fan-out-runtime.d.ts

@@ -29,6 +29,8 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildFanOutRuntime", Interface>;
 export declare class Service extends Service_base {
 }
+export declare const layerFromRuntime: Layer.Layer<Service, ChildFanOutRuntimeError, ChildFanOutRepository.Service | TransitionService | HandlerService>;
 export declare const layer: Layer.Layer<Service, ChildFanOutRuntimeError, ChildFanOutRepository.Service | TransitionService | HandlerService>;
+export declare const handlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
 export declare const testHandlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
 export {};