@relayfx/sdk 0.2.13 → 0.2.15

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

@@ -91,11 +91,22 @@ export declare const StartExecutionInput: Schema.Struct<{
             readonly [x: string]: Schema.Json;
         };
         readonly instructions?: string;
-        readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-            readonly context_window: Schema.Number;
-            readonly reserve_tokens: Schema.Number;
-            readonly keep_recent_tokens: Schema.Number;
-        }, "Encoded">;
+        readonly compaction_policy?: {
+            readonly context_window: number;
+            readonly reserve_tokens: number;
+            readonly keep_recent_tokens: number;
+            readonly summary_model?: {
+                readonly provider: string;
+                readonly model: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+        };
         readonly output_schema_ref?: string;
         readonly skill_definition_ids?: readonly string[];
         readonly permission_rules?: {
@@ -128,11 +139,22 @@ export declare const StartExecutionInput: Schema.Struct<{
                     };
                 };
                 readonly instructions?: string;
-                readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-                    readonly context_window: Schema.Number;
-                    readonly reserve_tokens: Schema.Number;
-                    readonly keep_recent_tokens: Schema.Number;
-                }, "Encoded">;
+                readonly compaction_policy?: {
+                    readonly context_window: number;
+                    readonly reserve_tokens: number;
+                    readonly keep_recent_tokens: number;
+                    readonly summary_model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
+                };
                 readonly tool_names?: readonly string[];
                 readonly workspace_policy?: {
                     readonly mode: "share" | "fork";
@@ -1088,6 +1110,13 @@ export declare const SpawnChildRunInput: Schema.Struct<{
         readonly context_window: Schema.Number;
         readonly reserve_tokens: Schema.Number;
         readonly keep_recent_tokens: Schema.Number;
+        readonly summary_model: Schema.optionalKey<Schema.Struct<{
+            readonly provider: Schema.String;
+            readonly model: Schema.String;
+            readonly registration_key: Schema.optionalKey<Schema.String>;
+            readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
     }>>;
     readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
     readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
@@ -1177,6 +1206,13 @@ export declare const CreateChildFanOutInput: Schema.Struct<{
                 readonly context_window: Schema.Number;
                 readonly reserve_tokens: Schema.Number;
                 readonly keep_recent_tokens: Schema.Number;
+                readonly summary_model: Schema.optionalKey<Schema.Struct<{
+                    readonly provider: Schema.String;
+                    readonly model: Schema.String;
+                    readonly registration_key: Schema.optionalKey<Schema.String>;
+                    readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>>;
             }>>;
             readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
             readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
@@ -1346,6 +1382,13 @@ export declare const CancelChildFanOutResult: Schema.Struct<{
                     readonly context_window: Schema.Number;
                     readonly reserve_tokens: Schema.Number;
                     readonly keep_recent_tokens: Schema.Number;
+                    readonly summary_model: Schema.optionalKey<Schema.Struct<{
+                        readonly provider: Schema.String;
+                        readonly model: Schema.String;
+                        readonly registration_key: Schema.optionalKey<Schema.String>;
+                        readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                    }>>;
                 }>>;
                 readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
                 readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
@@ -1514,6 +1557,13 @@ export declare const InspectChildFanOutResult: Schema.Struct<{
                     readonly context_window: Schema.Number;
                     readonly reserve_tokens: Schema.Number;
                     readonly keep_recent_tokens: Schema.Number;
+                    readonly summary_model: Schema.optionalKey<Schema.Struct<{
+                        readonly provider: Schema.String;
+                        readonly model: Schema.String;
+                        readonly registration_key: Schema.optionalKey<Schema.String>;
+                        readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                    }>>;
                 }>>;
                 readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
                 readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;

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

@@ -0,0 +1,13 @@
+import { Effect, type Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { DatabaseIdentity, DatabaseLayer, RuntimeConfigurationError, RuntimeMigrationError } from "./runtime";
+export 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 declare const Postgres: {
+    readonly runtimeDatabaseLayer: typeof runtimeDatabaseLayer;
+    readonly migrate: typeof migrate;
+};

package/dist/types/relay/runtime-capability-policy.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer, Schema } from "effect";
+declare const RuntimeCapabilityUnavailable_base: Schema.Class<RuntimeCapabilityUnavailable, Schema.TaggedStruct<"RuntimeCapabilityUnavailable", {
+    readonly capability: Schema.Literals<readonly ["fan-out", "workflow-definition"]>;
+    readonly role: Schema.Literals<readonly ["embedded", "runner", "client"]>;
+    readonly nextAction: Schema.Literals<readonly ["enable-embedded-capability", "use-embedded-runtime"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class RuntimeCapabilityUnavailable extends RuntimeCapabilityUnavailable_base {
+}
+export interface Interface {
+    readonly admit: (capability: "fan-out" | "workflow-definition") => Effect.Effect<void, RuntimeCapabilityUnavailable>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/RuntimeCapabilityPolicy", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (role: "embedded" | "runner" | "client", capabilities: {
+    readonly fanOut: boolean;
+    readonly workflowDefinition: boolean;
+}) => Layer.Layer<Service, never, never>;
+export {};

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

@@ -0,0 +1,12 @@
+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: {
+    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>;

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

@@ -0,0 +1,21 @@
+import { Context, type Effect } from "effect";
+import type { DatabaseIdentity, RuntimeMigrationError } from "./runtime";
+export { Dialect } from "./runtime";
+export type Interface = {
+    readonly dialect: "sqlite";
+    readonly databaseIdentity: DatabaseIdentity;
+    readonly ownership: "runtime-exclusive";
+    readonly schemaHead: string;
+    readonly notification: "in-process";
+    readonly acquireSchema: Effect.Effect<void, RuntimeMigrationError>;
+} | {
+    readonly dialect: "pg" | "mysql";
+    readonly databaseIdentity: DatabaseIdentity;
+    readonly ownership: "shared-multi-node";
+    readonly schemaHead: string;
+    readonly notification: "pg-listen-notify" | "polling";
+    readonly verifySchema: Effect.Effect<void, RuntimeMigrationError>;
+};
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/RuntimeDatabase", Interface>;
+export declare class Service extends Service_base {
+}

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/address/address-resolution-service.d.ts

@@ -79,11 +79,22 @@ export declare const LocalAgentTarget: Schema.Struct<{
             readonly [x: string]: Schema.Json;
         };
         readonly instructions?: string;
-        readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-            readonly context_window: Schema.Number;
-            readonly reserve_tokens: Schema.Number;
-            readonly keep_recent_tokens: Schema.Number;
-        }, "Encoded">;
+        readonly compaction_policy?: {
+            readonly context_window: number;
+            readonly reserve_tokens: number;
+            readonly keep_recent_tokens: number;
+            readonly summary_model?: {
+                readonly provider: string;
+                readonly model: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+        };
         readonly output_schema_ref?: string;
         readonly skill_definition_ids?: readonly string[];
         readonly permission_rules?: {
@@ -116,11 +127,22 @@ export declare const LocalAgentTarget: Schema.Struct<{
                     };
                 };
                 readonly instructions?: string;
-                readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-                    readonly context_window: Schema.Number;
-                    readonly reserve_tokens: Schema.Number;
-                    readonly keep_recent_tokens: Schema.Number;
-                }, "Encoded">;
+                readonly compaction_policy?: {
+                    readonly context_window: number;
+                    readonly reserve_tokens: number;
+                    readonly keep_recent_tokens: number;
+                    readonly summary_model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
+                };
                 readonly tool_names?: readonly string[];
                 readonly workspace_policy?: {
                     readonly mode: "share" | "fork";

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

@@ -1,11 +1,12 @@
-import { Compaction } from "@batonfx/core";
+import { Compaction, ModelRegistry } from "@batonfx/core";
 import { Ids } from "../../schema/index";
 import { CompactionRepository } from "../../store-sql/portable";
-import { Layer } from "effect";
+import { Effect, Layer } from "effect";
 export interface Options {
     readonly contextWindow?: number;
     readonly reserveTokens?: number;
     readonly keepRecentTokens?: number;
+    readonly summaryModel?: Effect.Effect<Layer.Layer<ModelRegistry.ModelEnvironment>, Compaction.CompactionError>;
 }
 export interface Config {
     readonly executionId: Ids.ExecutionId;

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 {};

package/dist/types/runtime/child/spawn-child-run-tool.d.ts

@@ -20,6 +20,13 @@ export declare const Input: Schema.Struct<{
         readonly context_window: Schema.Number;
         readonly reserve_tokens: Schema.Number;
         readonly keep_recent_tokens: Schema.Number;
+        readonly summary_model: Schema.optionalKey<Schema.Struct<{
+            readonly provider: Schema.String;
+            readonly model: Schema.String;
+            readonly registration_key: Schema.optionalKey<Schema.String>;
+            readonly request_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
     }>>;
     readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
     readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;

package/dist/types/runtime/model/language-model-service.d.ts

@@ -29,6 +29,7 @@ export declare const memoryLayer: (initialRegistrations?: ReadonlyArray<Registra
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const register: (input: ModelRegistry.RegisterInput) => Effect.Effect<void, never, Service>;
 export declare const registrations: () => Effect.Effect<readonly ModelRegistry.Registration[], never, Service>;
+export declare const resolve: (selection: Agent.ModelSelection) => Effect.Effect<ModelRegistry.Registration, ModelRegistry.LanguageModelNotRegistered, Service>;
 export declare const provide: <A, E, R>(selection: Agent.ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, ModelRegistry.LanguageModelNotRegistered | E, Service | Exclude<R, ModelRegistry.ModelEnvironment>>;
 export declare const provideForAgent: <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, ModelRegistry.LanguageModelNotRegistered | E, Service | Exclude<R, ModelRegistry.ModelEnvironment>>;
 export {};