@relayfx/sdk 0.0.1

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

@@ -0,0 +1,393 @@
+import type { ExecutionRepository } from "../../store-sql/index";
+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 type * as EventLog from "../execution/event-log-service";
+import type * as WaitService from "../wait/wait-service";
+import * as ExecutionWorkflow from "../workflow/execution-workflow";
+export declare const Start: Rpc.Rpc<"start", 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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly event_sequence: Schema.Int;
+    readonly started_at: Schema.Int;
+    readonly completed_at: Schema.Int;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    }>;
+    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: 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.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly value: 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 child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            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 workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            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 output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, 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"]>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never>;
+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 ExecutionWorkflow.ExecutionWorkflowFailed, never, never>;
+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 ExecutionWorkflow.ExecutionWorkflowFailed, never, never>;
+export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", 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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly event_sequence: Schema.Int;
+    readonly started_at: Schema.Int;
+    readonly completed_at: Schema.Int;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    }>;
+    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: 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.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly value: 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 child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            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 workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            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 output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, 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"]>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | 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 ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | 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 ExecutionWorkflow.ExecutionWorkflowFailed, never, never>>;
+export declare const layer: import("effect/Layer").Layer<never, never, ExecutionRepository.Service | EventLog.Service | WaitService.Service | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<Rpc.Rpc<"start", 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 root_address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        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 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 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 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 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 metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>>;
+    readonly event_sequence: Schema.Int;
+    readonly started_at: Schema.Int;
+    readonly completed_at: Schema.Int;
+    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    }>;
+    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: 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.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly value: 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 child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            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 workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            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 output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, 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"]>;
+    readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | 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 ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | 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 ExecutionWorkflow.ExecutionWorkflowFailed, never, never>, 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>;

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

@@ -0,0 +1,73 @@
+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>;
+/**
+ * @experimental
+ */
+export declare class ArtifactNotResolvable extends ArtifactNotResolvable_base {
+}
+/**
+ * Artifacts resolve to Content parts (an artifact may be text, structured data,
+ * or a blob reference). Resolution is single-level: the assembler resolves any
+ * produced `blob-reference` through `BlobStore` in the same pass, but a nested
+ * `artifact-reference` is an error.
+ *
+ * @experimental
+ */
+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>;
+/**
+ * @experimental
+ */
+export declare class Service extends Service_base {
+}
+/**
+ * Default store: preserves today's behavior — every artifact reference resolves
+ * to a single text part carrying the stringified reference.
+ *
+ * @experimental
+ */
+export declare const passthroughLayer: Layer.Layer<Service>;
+/**
+ * Memory store implementation plus a `register` helper for tests.
+ *
+ * @experimental
+ */
+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>;
+/**
+ * @experimental
+ */
+export declare class Memory extends Memory_base {
+}
+/**
+ * In-memory store; `resolve` fails typed when the artifact is unknown. Provides
+ * both {@link Service} and {@link Memory} (for `register` in tests).
+ *
+ * @experimental
+ */
+export declare const memoryLayer: Layer.Layer<Service | Memory>;
+/**
+ * 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.ArtifactReferencePart) => Effect.Effect<readonly Content.Part[], ArtifactNotResolvable, Service>;
+/**
+ * Registers artifact parts in the memory store (see {@link memoryLayer}).
+ *
+ * @experimental
+ */
+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,87 @@
+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>;
+/**
+ * @experimental
+ */
+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>;
+/**
+ * @experimental
+ */
+export declare class BlobStoreError extends BlobStoreError_base {
+}
+/**
+ * What a resolved blob looks like to the loop. `Url` means "pass this through to
+ * the provider as-is"; `Bytes` means "hand these bytes to the provider".
+ *
+ * @experimental
+ */
+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;
+};
+/**
+ * @experimental
+ */
+export interface PutBlobInput {
+    readonly bytes: Uint8Array;
+    readonly mediaType: string;
+    readonly fileName?: string;
+    readonly metadata?: Shared.Metadata;
+}
+/**
+ * @experimental
+ */
+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>;
+/**
+ * @experimental
+ */
+export declare class Service extends Service_base {
+}
+/**
+ * Default store: preserves today's behavior bit-for-bit. `resolve` returns the
+ * reference uri as a passthrough `Url`; `put` is unsupported.
+ *
+ * @experimental
+ */
+export declare const passthroughLayer: Layer.Layer<Service>;
+/**
+ * In-memory store. `put` mints monotonic `memory://blob/<n>` uris (no
+ * `Math.random`); `resolve` fails typed when the uri is unknown.
+ *
+ * @experimental
+ */
+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/envelope/envelope-service.d.ts

@@ -0,0 +1,52 @@
+import { Envelope, Execution, Ids } from "../../schema/index";
+import { EnvelopeRepository } from "../../store-sql/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as AddressBook from "../address/address-book-service";
+import * as EventLog 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, 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 | AddressBook.Service | EventLog.Service>;
+export declare const memoryLayer: (routes?: Iterable<readonly [Ids.AddressId, AddressBook.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 {};