@relayfx/sdk 0.0.50 → 0.2.0

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

@@ -0,0 +1,54 @@
+import { Effect } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+export declare const migrations: readonly [{
+    readonly id: 1;
+    readonly name: "baseline";
+    readonly file: "0001_baseline.sql";
+    readonly source: string;
+}, {
+    readonly id: 2;
+    readonly name: "durable_tool_placement";
+    readonly file: "0002_durable_tool_placement.sql";
+    readonly source: string;
+}, {
+    readonly id: 3;
+    readonly name: "durable_inbox";
+    readonly file: "0003_durable_inbox.sql";
+    readonly source: string;
+}, {
+    readonly id: 4;
+    readonly name: "execution_state";
+    readonly file: "0004_execution_state.sql";
+    readonly source: string;
+}, {
+    readonly id: 5;
+    readonly name: "durable_entities";
+    readonly file: "0005_durable_entities.sql";
+    readonly source: string;
+}, {
+    readonly id: 6;
+    readonly name: "ephemeral_presence";
+    readonly file: "0006_ephemeral_presence.sql";
+    readonly source: string;
+}, {
+    readonly id: 7;
+    readonly name: "topic_subscriptions";
+    readonly file: "0007_topic_subscriptions.sql";
+    readonly source: string;
+}, {
+    readonly id: 8;
+    readonly name: "child_fan_out";
+    readonly file: "0008_child_fan_out.sql";
+    readonly source: string;
+}, {
+    readonly id: 9;
+    readonly name: "workflow_definitions";
+    readonly file: "0009_workflow_definitions.sql";
+    readonly source: string;
+}, {
+    readonly id: 10;
+    readonly name: "workflow_runtime";
+    readonly file: "0010_workflow_runtime.sql";
+    readonly source: string;
+}];
+export declare const loader: Effect.Effect<(readonly [1 | 2 | 6 | 3 | 4 | 7 | 8 | 5 | 9 | 10, "baseline" | "durable_tool_placement" | "durable_inbox" | "execution_state" | "durable_entities" | "ephemeral_presence" | "topic_subscriptions" | "child_fan_out" | "workflow_definitions" | "workflow_runtime", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;

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

@@ -0,0 +1,10 @@
+import { type SqliteClientConfig } from "@effect/sql-sqlite-bun/SqliteClient";
+import { ChildFanOutRuntime, WorkflowDefinitionRuntime } from "../runtime/index";
+import { WorkflowDefinitionRepository } from "../store-sql/portable";
+import { Layer } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+export declare const clientLayer: (options: SqliteClientConfig) => Layer.Layer<SqlClient | import("@effect/sql-sqlite-bun/SqliteClient").SqliteClient, never, never>;
+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>>;
+export declare const childFanOutLayer: <E, R>(options: SqliteClientConfig, handlersLayer: Layer.Layer<ChildFanOutRuntime.HandlerService, E, R>) => Layer.Layer<ChildFanOutRuntime.Service, unknown, R>;

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

@@ -0,0 +1,29 @@
+export * as Client from "./client";
+export * as Operation from "./operation";
+export * as SQLite from "./sqlite-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 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";

package/dist/types/runtime/address/address-book-service.d.ts

@@ -1,10 +1,10 @@
 import { Address, Ids } from "../../schema/index";
-import { AddressBookRepository } from "../../store-sql/index";
+import { AddressBookRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
-export declare const RouteKind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+export declare const RouteKind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
 export type RouteKind = typeof RouteKind.Type;
 export declare const Route: Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+    readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
     readonly route_key: Schema.String;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>;
@@ -18,7 +18,7 @@ export declare const RouteRecord: Schema.Struct<{
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
     readonly route: Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+        readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
         readonly route_key: Schema.String;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>;

package/dist/types/runtime/address/address-resolution-service.d.ts

@@ -14,7 +14,7 @@ declare const AddressRouteKindMismatch_base: Schema.Class<AddressRouteKindMismat
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
     readonly expected: Schema.Literal<"local-agent">;
-    readonly actual: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+    readonly actual: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
     readonly route_key: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class AddressRouteKindMismatch extends AddressRouteKindMismatch_base {

package/dist/types/runtime/agent/agent-loop-service.d.ts

@@ -1,5 +1,5 @@
 import { Agent, Content, Execution, Ids, Shared, Tool } from "../../schema/index";
-import { AgentChatRepository } from "../../store-sql/index";
+import { AgentChatRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Tool as AiTool } from "effect/unstable/ai";
 import type { DispatchInput } from "../child/spawn-child-run-tool";
@@ -81,5 +81,5 @@ export declare const toolFromDefinition: (definition: Tool.Definition) => AiTool
 export declare const mapBoundaryError: (error: unknown, current: Execution.ExecutionEventSequence) => AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
 export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLogService | ToolRuntimeService | LanguageModelServiceService | ModelCallPolicyService | SchemaRegistryService | PromptAssemblerService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded, Service>;
+export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopBudgetExceeded | AgentLoopWaitRequested, Service>;
 export {};

package/dist/types/runtime/agent/agent-registry-service.d.ts

@@ -1,5 +1,5 @@
 import { Agent, Ids } from "../../schema/index";
-import { AgentDefinitionRepository } from "../../store-sql/index";
+import { AgentDefinitionRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
 declare const AgentDefinitionInvalid_base: Schema.Class<AgentDefinitionInvalid, Schema.TaggedStruct<"AgentDefinitionInvalid", {
     readonly message: Schema.String;

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

@@ -1,6 +1,6 @@
 import { Compaction } from "@batonfx/core";
 import { Ids } from "../../schema/index";
-import { CompactionRepository } from "../../store-sql/index";
+import { CompactionRepository } from "../../store-sql/portable";
 import { Layer } from "effect";
 export interface Options {
     readonly contextWindow?: number;

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

@@ -1,6 +1,6 @@
 import { Permissions } from "@batonfx/core";
 import { Agent, Execution, Ids } from "../../schema/index";
-import { PermissionRuleRepository } from "../../store-sql/index";
+import { PermissionRuleRepository } from "../../store-sql/portable";
 import { Effect, Layer } from "effect";
 import type { Interface as EventLogInterface } from "../execution/event-log-service";
 import type { Interface as WaitServiceInterface } from "../wait/wait-service";

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

@@ -1,6 +1,6 @@
 import { Steering } from "@batonfx/core";
 import { Execution, Ids } from "../../schema/index";
-import { SteeringRepository } from "../../store-sql/index";
+import { SteeringRepository } from "../../store-sql/portable";
 import { Effect, Layer } from "effect";
 import type { Interface } from "../execution/event-log-service";
 export interface SequenceAllocator {

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

@@ -0,0 +1,30 @@
+import { ChildOrchestration, Execution, Ids } from "../../schema/index";
+import { ChildFanOutRepository } from "../../store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as ChildRunService, type AgentContext } from "./child-run-service";
+declare const ChildFanOutAdmissionError_base: Schema.Class<ChildFanOutAdmissionError, Schema.TaggedStruct<"ChildFanOutAdmissionError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ChildFanOutAdmissionError extends ChildFanOutAdmissionError_base {
+}
+export interface AdmitInput {
+    readonly fanOutId: Ids.ChildFanOutId;
+    readonly parent: AgentContext;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly admittedAt: number;
+}
+export interface Interface {
+    readonly admit: (input: AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
+    readonly recover: (input: AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
+    readonly recoverAll: (inputFor: (fanOut: ChildOrchestration.FanOutState) => AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildFanOutAdmissionService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, ChildFanOutRepository.Service | ChildRunService>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const admit: (input: AdmitInput) => Effect.Effect<readonly Execution.ChildRunAccepted[], ChildFanOutAdmissionError, Service>;
+export declare const recover: (input: AdmitInput) => Effect.Effect<readonly Execution.ChildRunAccepted[], ChildFanOutAdmissionError, Service>;
+export declare const recoverAll: (inputFor: (fanOut: ChildOrchestration.FanOutState) => AdmitInput) => Effect.Effect<readonly Execution.ChildRunAccepted[], ChildFanOutAdmissionError, Service>;
+export {};

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

@@ -0,0 +1,34 @@
+import { ChildOrchestration, Content, Ids } from "../../schema/index";
+import { ChildFanOutRepository } from "../../store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as TransitionService } from "./child-fan-out-transition-service";
+export interface ChildResult {
+    readonly status: "completed" | "failed" | "cancelled";
+    readonly output: ReadonlyArray<Content.Part>;
+    readonly error?: string;
+    readonly completedAt?: number;
+}
+export interface Handlers {
+    readonly execute: (child: ChildOrchestration.FanOutChild, fanOut: ChildOrchestration.FanOutState, idempotencyKey: string) => Effect.Effect<ChildResult, unknown>;
+    readonly cancel: (childExecutionId: Ids.ChildExecutionId, reason: string) => Effect.Effect<void, unknown>;
+}
+declare const HandlerService_base: Context.ServiceClass<HandlerService, "@relayfx/runtime/ChildFanOutRuntimeHandlers", Handlers>;
+export declare class HandlerService extends HandlerService_base {
+}
+declare const ChildFanOutRuntimeError_base: Schema.Class<ChildFanOutRuntimeError, Schema.TaggedStruct<"ChildFanOutRuntimeError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ChildFanOutRuntimeError extends ChildFanOutRuntimeError_base {
+}
+export interface Interface {
+    readonly create: (definition: ChildOrchestration.FanOutDefinition) => Effect.Effect<ChildOrchestration.FanOutState, ChildFanOutRuntimeError>;
+    readonly recover: () => Effect.Effect<ReadonlyArray<Ids.ChildFanOutId>, ChildFanOutRuntimeError>;
+    readonly cancel: (fanOutId: Ids.ChildFanOutId, cancelledAt: number, reason: string) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRuntimeError>;
+    readonly inspect: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRuntimeError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildFanOutRuntime", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, ChildFanOutRuntimeError, ChildFanOutRepository.Service | TransitionService | HandlerService>;
+export declare const testHandlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
+export {};

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

@@ -0,0 +1,25 @@
+import { Content, Ids } from "../../schema/index";
+import { ChildFanOutRepository } from "../../store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as EventLogService } from "../execution/event-log-service";
+declare const ChildFanOutTransitionError_base: Schema.Class<ChildFanOutTransitionError, Schema.TaggedStruct<"ChildFanOutTransitionError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ChildFanOutTransitionError extends ChildFanOutTransitionError_base {
+}
+export interface TerminalInput {
+    readonly childExecutionId: Ids.ChildExecutionId;
+    readonly status: "completed" | "failed" | "cancelled";
+    readonly output: ReadonlyArray<Content.Part>;
+    readonly error?: string;
+    readonly completedAt: number;
+}
+export interface Interface {
+    readonly terminal: (input: TerminalInput) => Effect.Effect<ChildFanOutRepository.RecordTerminalResult | undefined, ChildFanOutTransitionError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildFanOutTransitionService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, ChildFanOutRepository.Service | EventLogService>;
+export declare const terminal: (input: TerminalInput) => Effect.Effect<ChildFanOutRepository.RecordTerminalResult | undefined, ChildFanOutTransitionError, Service>;
+export {};

package/dist/types/runtime/child/child-run-service.d.ts

@@ -1,5 +1,5 @@
 import { Agent, Execution, Ids, Shared } from "../../schema/index";
-import { ChildExecutionRepository } from "../../store-sql/index";
+import { ChildExecutionRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Service as EventLogService } from "../execution/event-log-service";
 declare const StaticChildRunPresetNotFound_base: Schema.Class<StaticChildRunPresetNotFound, Schema.TaggedStruct<"StaticChildRunPresetNotFound", {

package/dist/types/runtime/child/parent-notifier-service.d.ts

@@ -1,5 +1,5 @@
 import { Content, Ids } from "../../schema/index";
-import { ChildExecutionRepository } from "../../store-sql/index";
+import { ChildExecutionRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Ref, Schema } from "effect";
 import { Service as EventLogService } from "../execution/event-log-service";
 import { Service as WaitServiceService } from "../wait/wait-service";

package/dist/types/runtime/cluster/execution-entity.d.ts

@@ -1,13 +1,15 @@
-import type { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "../../store-sql/index";
+import type { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "../../store-sql/portable";
 import { Entity } from "effect/unstable/cluster";
 import { Rpc } from "effect/unstable/rpc";
 import type { WorkflowEngine } from "effect/unstable/workflow";
 import { Schema } from "effect";
 import type { Effect } from "effect";
 import { ExecutionWorkflowFailed, StartInput, StartResult } from "../workflow/execution-workflow";
+import type { Service as ActiveExecutionRegistryService } from "../execution/active-execution-registry";
 import type { Service as EventLogService } from "../execution/event-log-service";
-import type { Service as WaitServiceService } from "../wait/wait-service";
+import type { Service as ExecutionServiceService } from "../execution/execution-service";
 import type { Service as ToolTransitionCoordinatorService } from "../tool/tool-transition-coordinator";
+import type { Service as WaitServiceService } from "../wait/wait-service";
 export declare const Start: Rpc.Rpc<"start", typeof StartInput, typeof StartResult, typeof ExecutionWorkflowFailed>;
 export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly workflow_execution_id: Schema.String;
@@ -32,6 +34,6 @@ export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
 }>, typeof ExecutionWorkflowFailed, never, never>;
 type ExecutionRpc = typeof Start | typeof Dispatch | typeof SignalWait | typeof Cancel;
 export declare const entity: Entity.Entity<"Relay/Execution", ExecutionRpc>;
-export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | WaitServiceService | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | WaitServiceService | ExecutionServiceService | ActiveExecutionRegistryService | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
 export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<ExecutionRpc, import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;
 export {};

package/dist/types/runtime/entity/entity-instance-service.d.ts

@@ -0,0 +1,67 @@
+import { Content, Entity, Ids, Shared } from "../../schema/index";
+import { EntityRepository } from "../../store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as AddressBookService } from "../address/address-book-service";
+import { Service as AgentRegistryService } from "../agent/agent-registry-service";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { EntityKindInvalid, EntityKindNotFound, Service as EntityRegistryService } from "./entity-registry-service";
+declare const EntityDestroyed_base: Schema.Class<EntityDestroyed, Schema.TaggedStruct<"EntityDestroyed", {
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityDestroyed extends EntityDestroyed_base {
+}
+declare const EntityNotFound_base: Schema.Class<EntityNotFound, Schema.TaggedStruct<"EntityNotFound", {
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityNotFound extends EntityNotFound_base {
+}
+declare const EntityServiceError_base: Schema.Class<EntityServiceError, Schema.TaggedStruct<"EntityServiceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityServiceError extends EntityServiceError_base {
+}
+export interface GetOrCreateInput {
+    readonly kind: Ids.EntityKindName;
+    readonly key: Ids.EntityKey;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface Interface {
+    readonly getOrCreate: (input: GetOrCreateInput) => Effect.Effect<Entity.Instance, EntityKindNotFound | EntityKindInvalid | EntityServiceError>;
+    readonly get: (input: {
+        readonly kind: Ids.EntityKindName;
+        readonly key: Ids.EntityKey;
+    }) => Effect.Effect<Entity.Instance | undefined, EntityServiceError>;
+    readonly destroy: (input: {
+        readonly kind: Ids.EntityKindName;
+        readonly key: Ids.EntityKey;
+        readonly reason?: string;
+        readonly destroyedAt: number;
+    }) => Effect.Effect<Entity.Instance, EntityNotFound | EntityDestroyed | EntityServiceError>;
+    readonly list: (input: {
+        readonly kind?: Ids.EntityKindName;
+        readonly afterKind?: Ids.EntityKindName;
+        readonly afterKey?: string;
+        readonly limit?: number;
+    }) => Effect.Effect<ReadonlyArray<Entity.Instance>, EntityServiceError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EntityInstanceService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const entityExecutionId: (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey, generation: number) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+export declare const entityAddressId: (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+export declare const entitySessionId: (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey) => string & import("effect/Brand").Brand<"Relay.SessionId">;
+export declare const layer: Layer.Layer<Service, never, EntityRepository.Service | AddressBookService | EventLogService | AgentRegistryService | import("effect/unstable/cluster/Sharding").Sharding | EntityRegistryService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

package/dist/types/runtime/entity/entity-registry-service.d.ts

@@ -0,0 +1,35 @@
+import { Entity, Ids } from "../../schema/index";
+import { EntityRepository } from "../../store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as AgentRegistryService } from "../agent/agent-registry-service";
+declare const EntityKindNotFound_base: Schema.Class<EntityKindNotFound, Schema.TaggedStruct<"EntityKindNotFound", {
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityKindNotFound extends EntityKindNotFound_base {
+}
+declare const EntityKindInvalid_base: Schema.Class<EntityKindInvalid, Schema.TaggedStruct<"EntityKindInvalid", {
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityKindInvalid extends EntityKindInvalid_base {
+}
+declare const EntityRegistryError_base: Schema.Class<EntityRegistryError, Schema.TaggedStruct<"EntityRegistryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityRegistryError extends EntityRegistryError_base {
+}
+export interface Interface {
+    readonly registerKind: (input: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, EntityKindInvalid | EntityRegistryError>;
+    readonly getKind: (kind: Ids.EntityKindName) => Effect.Effect<Entity.KindDefinition | undefined, EntityRegistryError>;
+    readonly listKinds: () => Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRegistryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EntityRegistry", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, EntityRepository.Service | AgentRegistryService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

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

@@ -1,5 +1,5 @@
 import { Envelope, Execution, Ids } from "../../schema/index";
-import { EnvelopeRepository } from "../../store-sql/index";
+import { EnvelopeRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Route, Service as AddressBookService } from "../address/address-book-service";
 import { Service as EventLogService } from "../execution/event-log-service";
@@ -40,7 +40,9 @@ export interface SendInput {
     readonly waitId?: Ids.WaitId;
 }
 export interface Interface {
-    readonly send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError>;
+    readonly send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted & {
+        readonly route_kind?: Route["kind"];
+    }, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EnvelopeService", Interface>;
 export declare class Service extends Service_base {
@@ -48,5 +50,7 @@ export declare class Service extends Service_base {
 export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | AddressBookService | EventLogService>;
 export declare const memoryLayer: (routes?: Iterable<readonly [Ids.AddressId, Route]>) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError, Service>;
+export declare const send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted & {
+    readonly route_kind?: Route["kind"];
+}, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError, Service>;
 export {};

package/dist/types/runtime/execution/active-execution-registry.d.ts

@@ -0,0 +1,12 @@
+import { Ids } from "../../schema/index";
+import { Context, Effect, Layer } from "effect";
+export interface Interface {
+    readonly run: <A, E, R>(executionId: Ids.ExecutionId, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+    readonly interrupt: (executionId: Ids.ExecutionId) => Effect.Effect<boolean>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ActiveExecutionRegistry", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, never>;
+export declare const testLayer: Layer.Layer<Service, never, never>;
+export {};

package/dist/types/runtime/execution/event-log-service.d.ts

@@ -1,5 +1,5 @@
 import { Execution, Ids } from "../../schema/index";
-import { ExecutionEventRepository } from "../../store-sql/index";
+import { ExecutionEventRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
 declare const EventLogCursorNotFound_base: Schema.Class<EventLogCursorNotFound, Schema.TaggedStruct<"EventLogCursorNotFound", {
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {

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

@@ -1,5 +1,5 @@
 import { Agent, Envelope, Execution, Ids, Shared } from "../../schema/index";
-import { ExecutionRepository } from "../../store-sql/index";
+import { ExecutionRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema, Stream } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
 import { Service as ChildRunServiceService } from "../child/child-run-service";
@@ -41,6 +41,7 @@ export interface CancelInput {
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly cancelledAt: number;
     readonly reason?: string;
+    readonly metadata?: Shared.Metadata;
 }
 export interface Interface {
     readonly accept: (input: AcceptInput) => Effect.Effect<Execution.Execution, ExecutionServiceError>;

package/dist/types/runtime/execution/execution-watch-service.d.ts

@@ -0,0 +1,32 @@
+import { Execution, Ids } from "../../schema/index";
+import { ExecutionRepository } from "../../store-sql/portable";
+import { Context, Layer, Schema, Stream } from "effect";
+declare const ExecutionWatchError_base: Schema.Class<ExecutionWatchError, Schema.TaggedStruct<"ExecutionWatchError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionWatchError extends ExecutionWatchError_base {
+}
+export interface WatchInput {
+    readonly rootAddressId?: Ids.AddressId;
+    readonly sessionId?: Ids.SessionId;
+    readonly status?: Execution.ExecutionStatus;
+    readonly limit?: number;
+}
+export type ExecutionListChange = {
+    readonly _tag: "snapshot";
+    readonly records: ReadonlyArray<ExecutionRepository.ExecutionRecord>;
+    readonly nextCursor?: ExecutionRepository.ExecutionCursor;
+} | {
+    readonly _tag: "upsert";
+    readonly record: ExecutionRepository.ExecutionRecord;
+};
+export interface Interface {
+    readonly watch: (input: WatchInput) => Stream.Stream<ExecutionListChange, ExecutionWatchError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ExecutionWatch", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromServices: Layer.Layer<Service, never, ExecutionRepository.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, ExecutionRepository.Service>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

package/dist/types/runtime/execution/session-stream-service.d.ts

@@ -0,0 +1,33 @@
+import { Execution, Ids } from "../../schema/index";
+import { ExecutionRepository } from "../../store-sql/portable";
+import { Context, Layer, Schema, Stream } from "effect";
+import { EventLogCursorNotFound, Service as EventLogService } from "./event-log-service";
+declare const SessionStreamError_base: Schema.Class<SessionStreamError, Schema.TaggedStruct<"SessionStreamError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SessionStreamError extends SessionStreamError_base {
+}
+export interface StreamInput {
+    readonly sessionId: Ids.SessionId;
+    readonly resume?: ReadonlyArray<{
+        readonly executionId: Ids.ExecutionId;
+        readonly afterCursor?: string;
+    }>;
+}
+export type SessionStreamItem = {
+    readonly _tag: "execution_joined";
+    readonly record: ExecutionRepository.ExecutionRecord;
+} | {
+    readonly _tag: "execution_event";
+    readonly event: Execution.ExecutionEvent;
+};
+export interface Interface {
+    readonly stream: (input: StreamInput) => Stream.Stream<SessionStreamItem, EventLogCursorNotFound | SessionStreamError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/SessionStream", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromServices: Layer.Layer<Service, never, ExecutionRepository.Service | EventLogService>;
+export declare const memoryLayer: Layer.Layer<Service, never, ExecutionRepository.Service | EventLogService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};