@relayfx/test 0.1.0

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

@@ -0,0 +1,40 @@
+import { Content, Ids } from "../../schema/index";
+import { ChildExecutionRepository } from "@relayfx/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";
+declare const ParentNotifyError_base: Schema.Class<ParentNotifyError, Schema.TaggedStruct<"ParentNotifyError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ParentNotifyError extends ParentNotifyError_base {
+}
+export declare const ChildTerminalStatus: Schema.Literals<readonly ["completed", "failed", "cancelled"]>;
+export type ChildTerminalStatus = typeof ChildTerminalStatus.Type;
+export interface NotifyInput {
+    readonly parentExecutionId: Ids.ExecutionId;
+    readonly childExecutionId: Ids.ChildExecutionId;
+    readonly parentWaitId?: Ids.WaitId;
+    readonly status: ChildTerminalStatus;
+    readonly output: ReadonlyArray<Content.Part>;
+    readonly notifiedAt: number;
+}
+export interface Interface {
+    readonly notify: (input: NotifyInput) => Effect.Effect<void, ParentNotifyError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ParentNotifier", Interface>;
+export declare class Service extends Service_base {
+}
+export interface SignalParentWaitInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly waitId: Ids.WaitId;
+    readonly signaledAt: number;
+}
+export interface MakeOptions {
+    readonly signalWait: (input: SignalParentWaitInput) => Effect.Effect<void, unknown>;
+}
+export declare const make: (options: MakeOptions) => Effect.Effect<Interface, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;
+export declare const layerWith: (options: MakeOptions) => Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;
+export declare const memoryLayer: (notifications?: Ref.Ref<ReadonlyArray<NotifyInput>>) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const notify: (input: NotifyInput) => Effect.Effect<void, ParentNotifyError, Service>;
+export {};

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

@@ -0,0 +1,211 @@
+import { Agent, Content, Execution, Ids, Shared } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import type { RegisteredTool } from "../tool/tool-runtime-service";
+import type { Interface as EventLogInterface } from "../execution/event-log-service";
+import type { Interface as WaitServiceInterface } from "../wait/wait-service";
+import type { Interface as ChildRunServiceInterface } from "./child-run-service";
+export declare const toolName = "spawn_child_run";
+export declare const permissionName = "relay.child_run.spawn";
+export declare const Input: Schema.Struct<{
+    readonly preset_name: Schema.optionalKey<Schema.String>;
+    readonly instructions: Schema.optionalKey<Schema.String>;
+    readonly 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>>;
+    readonly output_schema_ref: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: 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 provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_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>>>;
+    }>]>>>;
+}>;
+export interface Input extends Schema.Schema.Type<typeof Input> {
+}
+export declare const Output: Schema.Struct<{
+    readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
+    };
+    readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled"]>;
+    readonly output: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: 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 provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_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>>>;
+    }>]>>;
+}>;
+export interface Output extends Schema.Schema.Type<typeof Output> {
+}
+export declare const TransferInput: Schema.Struct<{
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: 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 provider_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>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_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>>>;
+    }>]>>>;
+}>;
+export interface TransferInput extends Schema.Schema.Type<typeof TransferInput> {
+}
+export interface DispatchInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly rootAddressId: Ids.AddressId;
+    readonly input: ReadonlyArray<Content.Part>;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly agentId: Ids.AgentId;
+    readonly agentRevision: Agent.DefinitionRevision;
+    readonly agentSnapshot: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly metadata: Shared.Metadata;
+}
+export interface Config {
+    readonly agent: Agent.Definition;
+    readonly agentId: Ids.AgentId;
+    readonly agentRevision: Agent.DefinitionRevision;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly childRuns: ChildRunServiceInterface;
+    readonly eventLog: EventLogInterface;
+    readonly waits: WaitServiceInterface;
+    readonly dispatch: (input: DispatchInput) => Effect.Effect<void, unknown, any>;
+}
+export declare const enabled: (agent: Agent.Definition) => boolean;
+export declare const registeredTool: (config: Config) => RegisteredTool;
+export declare const transferToolName: (name: string) => string;
+export declare const transferTools: (config: Config) => ReadonlyArray<RegisteredTool>;

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

@@ -0,0 +1,37 @@
+import type { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "@relayfx/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 EventLogService } from "../execution/event-log-service";
+import type { Service as WaitServiceService } from "../wait/wait-service";
+import type { Service as ToolTransitionCoordinatorService } from "../tool/tool-transition-coordinator";
+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;
+    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    };
+    readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
+    readonly signaled_at: Schema.Int;
+}>, Schema.Void, typeof ExecutionWorkflowFailed, never, never>;
+export declare const Dispatch: Rpc.Rpc<"dispatch", typeof StartInput, typeof Schema.Void, typeof ExecutionWorkflowFailed>;
+export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
+    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 cancelled_at: Schema.Int;
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    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 status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
+}>, 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 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/content/artifact-store-service.d.ts

@@ -0,0 +1,26 @@
+import { Content } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+declare const ArtifactNotResolvable_base: Schema.Class<ArtifactNotResolvable, Schema.TaggedStruct<"ArtifactNotResolvable", {
+    readonly artifact_id: Schema.String;
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ArtifactNotResolvable extends ArtifactNotResolvable_base {
+}
+export interface Interface {
+    readonly resolve: (part: Content.ArtifactReferencePart) => Effect.Effect<ReadonlyArray<Content.Part>, ArtifactNotResolvable>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ArtifactStore", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const passthroughLayer: Layer.Layer<Service>;
+export interface MemoryInterface extends Interface {
+    readonly register: (artifact_id: string, parts: ReadonlyArray<Content.Part>) => Effect.Effect<void>;
+}
+declare const Memory_base: Context.ServiceClass<Memory, "@relayfx/runtime/ArtifactStore/Memory", MemoryInterface>;
+export declare class Memory extends Memory_base {
+}
+export declare const memoryLayer: Layer.Layer<Service | Memory>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+export declare const resolve: (part: Content.ArtifactReferencePart) => Effect.Effect<readonly Content.Part[], ArtifactNotResolvable, Service>;
+export declare const register: (artifact_id: string, parts: readonly Content.Part[]) => Effect.Effect<void, never, Memory>;
+export {};

package/dist/types/runtime/content/blob-store-service.d.ts

@@ -0,0 +1,54 @@
+import { Content, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+declare const BlobNotResolvable_base: Schema.Class<BlobNotResolvable, Schema.TaggedStruct<"BlobNotResolvable", {
+    readonly uri: Schema.String;
+    readonly reason: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BlobNotResolvable extends BlobNotResolvable_base {
+}
+declare const BlobStoreError_base: Schema.Class<BlobStoreError, Schema.TaggedStruct<"BlobStoreError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class BlobStoreError extends BlobStoreError_base {
+}
+export type ResolvedBlob = {
+    readonly _tag: "Bytes";
+    readonly bytes: Uint8Array;
+    readonly mediaType: string;
+    readonly fileName?: string;
+} | {
+    readonly _tag: "Url";
+    readonly url: string;
+    readonly mediaType: string;
+    readonly fileName?: string;
+};
+export interface PutBlobInput {
+    readonly bytes: Uint8Array;
+    readonly mediaType: string;
+    readonly fileName?: string;
+    readonly metadata?: Shared.Metadata;
+}
+export interface Interface {
+    readonly resolve: (part: Content.BlobReferencePart) => Effect.Effect<ResolvedBlob, BlobNotResolvable | BlobStoreError>;
+    readonly put: (input: PutBlobInput) => Effect.Effect<Content.BlobReferencePart, BlobStoreError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/BlobStore", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const passthroughLayer: Layer.Layer<Service>;
+export declare const memoryLayer: Layer.Layer<Service>;
+/**
+ * Wraps a custom store implementation as a layer.
+ *
+ * @experimental
+ */
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+/**
+ * @experimental
+ */
+export declare const resolve: (part: Content.BlobReferencePart) => Effect.Effect<ResolvedBlob, BlobNotResolvable | BlobStoreError, Service>;
+/**
+ * @experimental
+ */
+export declare const put: (input: PutBlobInput) => Effect.Effect<Content.BlobReferencePart, BlobStoreError, Service>;
+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 "@relayfx/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 "@relayfx/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

@@ -0,0 +1,56 @@
+import { Envelope, Execution, Ids } from "../../schema/index";
+import { EnvelopeRepository } from "@relayfx/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";
+declare const EnvelopeAddressNotFound_base: Schema.Class<EnvelopeAddressNotFound, Schema.TaggedStruct<"EnvelopeAddressNotFound", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeAddressNotFound extends EnvelopeAddressNotFound_base {
+}
+declare const EnvelopeRouteUnavailable_base: Schema.Class<EnvelopeRouteUnavailable, Schema.TaggedStruct<"EnvelopeRouteUnavailable", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly route_key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeRouteUnavailable extends EnvelopeRouteUnavailable_base {
+}
+declare const EnvelopeRouteDeferred_base: Schema.Class<EnvelopeRouteDeferred, Schema.TaggedStruct<"EnvelopeRouteDeferred", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly route_key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeRouteDeferred extends EnvelopeRouteDeferred_base {
+}
+declare const EnvelopeServiceError_base: Schema.Class<EnvelopeServiceError, Schema.TaggedStruct<"EnvelopeServiceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EnvelopeServiceError extends EnvelopeServiceError_base {
+}
+export interface SendInput {
+    readonly envelopeId: Ids.EnvelopeId;
+    readonly executionId: Ids.ExecutionId;
+    readonly input: Envelope.SendInput;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly createdAt: number;
+    readonly waitId?: Ids.WaitId;
+}
+export interface Interface {
+    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 {
+}
+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 & {
+    readonly route_kind?: Route["kind"];
+}, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError, Service>;
+export {};

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

@@ -0,0 +1,68 @@
+import { Execution, Ids } from "../../schema/index";
+import { ExecutionEventRepository } from "@relayfx/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"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly cursor: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EventLogCursorNotFound extends EventLogCursorNotFound_base {
+}
+declare const EventLogError_base: Schema.Class<EventLogError, Schema.TaggedStruct<"EventLogError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EventLogError extends EventLogError_base {
+}
+export interface ReplayInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly afterCursor?: string;
+    readonly limit?: number;
+}
+export interface FindBySequenceOrCursorInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sequence: Execution.ExecutionEventSequence;
+    readonly cursor: string;
+}
+export interface FindByCursorInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly cursor: string;
+}
+export interface FindBySequenceInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sequence: Execution.ExecutionEventSequence;
+}
+export interface FindFirstByTypeAfterSequenceInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly type: Execution.ExecutionEventType;
+    readonly afterSequence: Execution.ExecutionEventSequence;
+}
+export interface Interface {
+    readonly append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError>;
+    readonly replay: (input: ReplayInput) => Effect.Effect<ReadonlyArray<Execution.ExecutionEvent>, EventLogCursorNotFound | EventLogError>;
+    readonly stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | EventLogError>;
+    readonly findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
+    readonly findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
+    readonly findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
+    readonly findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
+    readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, EventLogError>;
+    readonly sumUsage: (executionId: Ids.ExecutionId) => Effect.Effect<number, EventLogError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EventLog", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromRepository: Layer.Layer<Service, never, ExecutionEventRepository.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const appendIdempotentTo: (eventLog: Interface, input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, never>;
+export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
+export declare const appendIdempotent: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
+export declare const replay: (input: ReplayInput) => Effect.Effect<readonly Execution.ExecutionEvent[], EventLogCursorNotFound | EventLogError, Service>;
+export declare const findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
+export declare const findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
+export declare const findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
+export declare const findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
+export declare const maxSequence: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number | undefined, EventLogError, Service>;
+export declare const sumUsage: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number, EventLogError, Service>;
+export declare const stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | EventLogError, Service>;
+export {};