@relayfx/sdk 0.0.39 → 0.0.40

package/dist/migrations/sqlite/0001_baseline.sql

@@ -26,18 +26,18 @@ CREATE TABLE "relay_agent_definitions" (
 --> statement-breakpoint
 CREATE INDEX "idx_relay_agent_definitions_name" ON "relay_agent_definitions" ("tenant_id", "name");
 --> statement-breakpoint
-CREATE TABLE "relay_agent_definition_revisions" (
+CREATE TABLE "relay_agent_revisions" (
 	"tenant_id" TEXT NOT NULL DEFAULT 'system',
-	"agent_definition_id" TEXT NOT NULL,
+	"agent_id" TEXT NOT NULL,
 	"revision" INTEGER NOT NULL,
 	"name" TEXT NOT NULL,
 	"definition_json" TEXT NOT NULL,
 	"tool_input_schema_digests_json" TEXT NOT NULL DEFAULT '{}',
 	"created_at" INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)),
-	CONSTRAINT "pk_relay_agent_definition_revisions" PRIMARY KEY ("tenant_id", "agent_definition_id", "revision")
+	CONSTRAINT "pk_relay_agent_revisions" PRIMARY KEY ("tenant_id", "agent_id", "revision")
 );
 --> statement-breakpoint
-CREATE INDEX "idx_relay_agent_definition_revisions_definition" ON "relay_agent_definition_revisions" ("tenant_id", "agent_definition_id", "revision");
+CREATE INDEX "idx_relay_agent_revisions_definition" ON "relay_agent_revisions" ("tenant_id", "agent_id", "revision");
 --> statement-breakpoint
 CREATE TABLE "relay_skill_definitions" (
 	"tenant_id" TEXT NOT NULL DEFAULT 'system',
@@ -194,10 +194,10 @@ CREATE TABLE "relay_executions" (
 	"root_address_id" TEXT NOT NULL,
 	"session_id" TEXT,
 	"status" TEXT NOT NULL,
-	"agent_definition_id" TEXT,
-	"agent_definition_revision" INTEGER,
-	"agent_definition_snapshot_json" TEXT,
-	"agent_definition_tool_input_schema_digests_json" TEXT NOT NULL DEFAULT '{}',
+	"agent_id" TEXT,
+	"agent_revision" INTEGER,
+	"agent_snapshot_json" TEXT,
+	"agent_tool_input_schema_digests_json" TEXT NOT NULL DEFAULT '{}',
 	"metadata_json" TEXT NOT NULL DEFAULT '{}',
 	"created_at" INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)),
 	"updated_at" INTEGER NOT NULL DEFAULT (CAST(unixepoch('subsec') * 1000 AS INTEGER)),

package/dist/types/ai/embedding-model/embedding-model-registration.d.ts

@@ -1,7 +1,5 @@
-import * as OpenAiClient from "@effect/ai-openai/OpenAiClient";
-import * as OpenAiEmbeddingModel from "@effect/ai-openai/OpenAiEmbeddingModel";
-import * as OpenAiCompatibleClient from "@effect/ai-openai-compat/OpenAiClient";
-import * as OpenAiCompatibleEmbeddingModel from "@effect/ai-openai-compat/OpenAiEmbeddingModel";
+import { OpenAiClient, OpenAiEmbeddingModel } from "@effect/ai-openai";
+import { OpenAiClient as OpenAiCompatibleClient, OpenAiEmbeddingModel as OpenAiCompatibleEmbeddingModel } from "@effect/ai-openai-compat";
 import { EmbeddingModelService } from "../../runtime/index";
 export interface OpenAiEmbeddingInput {
     readonly model: OpenAiEmbeddingModel.Model | (string & {});

package/dist/types/relay/adapter-outbox.d.ts

@@ -1,19 +1,19 @@
 import { Context, Effect, Layer } from "effect";
-import * as Client from "./client";
-import * as Operation from "./operation";
+import { ClientError, Service as ClientService } from "./client";
+import { AckEnvelopeReadyInput, ClaimEnvelopeReadyInput, EnvelopeReadyAcked, EnvelopeReadyLease, EnvelopeReadyReleased, ReleaseEnvelopeReadyInput, SubmitInboundEnvelopeAccepted, SubmitInboundEnvelopeInput } from "./operation";
 export interface Interface {
-    readonly claim: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, Client.ClientError>;
-    readonly ack: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, Client.ClientError>;
-    readonly release: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, Client.ClientError>;
-    readonly submitInbound: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, Client.ClientError>;
+    readonly claim: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError>;
+    readonly ack: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError>;
+    readonly release: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError>;
+    readonly submitInbound: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/AdapterOutbox", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Client.Service>;
+export declare const layer: Layer.Layer<Service, never, ClientService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const claim: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, Client.ClientError, Service>;
-export declare const ack: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, Client.ClientError, Service>;
-export declare const release: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, Client.ClientError, Service>;
-export declare const submitInbound: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, Client.ClientError, Service>;
+export declare const claim: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError, Service>;
+export declare const ack: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError, Service>;
+export declare const release: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError, Service>;
+export declare const submitInbound: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError, Service>;
 export {};

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

@@ -3,7 +3,7 @@ import { Address, Agent, Content, Envelope, Execution, Ids, Shared, Skill } from
 import { ClusterRegistryRepository, EnvelopeRepository, ExecutionRepository, ScheduleRepository, SessionRepository, SteeringRepository } from "../store-sql/index";
 import { Context, Effect, Layer, Schema, Stream } from "effect";
 import { Sharding, ShardingConfig } from "effect/unstable/cluster";
-import * as Operation from "./operation";
+import type { AckEnvelopeReadyInput, CancelExecutionAccepted, CancelExecutionInput, CancelScheduleInput, CancelScheduleResult, ClaimEnvelopeReadyInput, CreateScheduleInput, CreateScheduleResult, EnvelopeReadyAcked, EnvelopeReadyLease, EnvelopeReadyReleased, GetSessionInput, GetSessionResult, ListExecutionsInput, ListExecutionsResult, ListPendingApprovalsInput, ListRunnersResult, ListSchedulesInput, ListSchedulesResult, ListSessionsInput, ListSessionsResult, ListWaitsInput, PendingToolApprovalList, ReleaseEnvelopeReadyInput, ReplayExecutionInput, ReplayExecutionResult, ResolvePermissionInput, ResolveToolApprovalInput, RouteExecutionResult, StartExecutionInput, StartExecutionResult, SteerAccepted, SteerInput, StreamExecutionInput, SubmitInboundEnvelopeAccepted, SubmitInboundEnvelopeInput, WaitView, WakeAccepted, WakeInput } from "./operation";
 declare const ClientError_base: Schema.Class<ClientError, Schema.TaggedStruct<"ClientError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -24,7 +24,7 @@ export interface StartExecutionByAddressInput {
 export interface StartExecutionByAgentDefinitionInput {
     readonly root_address_id: Ids.AddressId;
     readonly session_id?: Ids.SessionId;
-    readonly agent_definition_id: Ids.AgentId;
+    readonly agent_id: Ids.AgentId;
     readonly input?: ReadonlyArray<Content.Part>;
     readonly idempotency_key: Shared.NonEmptyString;
     readonly execution_id?: Ids.ExecutionId;
@@ -37,35 +37,6 @@ export interface StartExecutionByAgentDefinitionInput {
 export interface RegisterAgentInput extends Agent.DefineInput {
     readonly address?: Ids.AddressId;
 }
-export interface AgentOptions extends Omit<Agent.DefineInput, "id" | "name" | "permissions"> {
-    readonly id?: Ids.AgentId;
-    readonly address?: Ids.AddressId;
-    readonly name?: Shared.NonEmptyString;
-    readonly permissions?: Agent.DefineInput["permissions"];
-}
-export interface RegisteredAgent {
-    readonly id: Ids.AgentId;
-    readonly address_id: Ids.AddressId;
-    readonly record: Agent.DefinitionRecord;
-}
-export type StartTarget = Ids.AddressId | RegisteredAgent | {
-    readonly address_id: Ids.AddressId;
-};
-export interface StartInput {
-    readonly session_id?: Ids.SessionId;
-    readonly input?: ReadonlyArray<Content.Part>;
-    readonly idempotency_key?: Shared.NonEmptyString;
-    readonly execution_id?: Ids.ExecutionId;
-    readonly event_sequence?: Execution.ExecutionEventSequence;
-    readonly started_at?: Shared.TimestampMillis;
-    readonly completed_at?: Shared.TimestampMillis;
-    readonly wait_id?: Ids.WaitId;
-    readonly metadata?: Shared.Metadata;
-}
-export interface RunInput extends StartInput {
-    readonly after_cursor?: Shared.NonEmptyString;
-    readonly limit?: number;
-}
 export interface Interface {
     readonly registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
@@ -78,33 +49,33 @@ export interface Interface {
     readonly registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError>;
     readonly getAddressBookRoute: (id: Ids.AddressId) => Effect.Effect<Address.RouteRecord | undefined, ClientError>;
     readonly listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError>;
-    readonly startExecution: (input: Operation.StartExecutionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError>;
-    readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<Operation.StartExecutionResult, ClientError>;
-    readonly startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError>;
-    readonly cancelExecution: (input: Operation.CancelExecutionInput) => Effect.Effect<Operation.CancelExecutionAccepted, ClientError>;
-    readonly steer: (input: Operation.SteerInput) => Effect.Effect<Operation.SteerAccepted, ClientError>;
+    readonly startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, ClientError>;
+    readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, ClientError>;
+    readonly startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, ClientError>;
+    readonly cancelExecution: (input: CancelExecutionInput) => Effect.Effect<CancelExecutionAccepted, ClientError>;
+    readonly steer: (input: SteerInput) => Effect.Effect<SteerAccepted, ClientError>;
     readonly getExecution: (id: Ids.ExecutionId) => Effect.Effect<Execution.Execution | undefined, ClientError>;
-    readonly listExecutions: (input: Operation.ListExecutionsInput) => Effect.Effect<Operation.ListExecutionsResult, ClientError>;
-    readonly listSessions: (input: Operation.ListSessionsInput) => Effect.Effect<Operation.ListSessionsResult, ClientError>;
-    readonly getSession: (input: Operation.GetSessionInput) => Effect.Effect<Operation.GetSessionResult, ClientError>;
-    readonly listWaits: (input: Operation.ListWaitsInput) => Effect.Effect<ReadonlyArray<Operation.WaitView>, ClientError>;
-    readonly replayExecution: (input: Operation.ReplayExecutionInput) => Effect.Effect<Operation.ReplayExecutionResult, ClientError>;
-    readonly listRunners: () => Effect.Effect<Operation.ListRunnersResult, ClientError>;
-    readonly routeExecution: (executionId: Ids.ExecutionId) => Effect.Effect<Operation.RouteExecutionResult, ClientError>;
+    readonly listExecutions: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ClientError>;
+    readonly listSessions: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, ClientError>;
+    readonly getSession: (input: GetSessionInput) => Effect.Effect<GetSessionResult, ClientError>;
+    readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitView>, ClientError>;
+    readonly replayExecution: (input: ReplayExecutionInput) => Effect.Effect<ReplayExecutionResult, ClientError>;
+    readonly listRunners: () => Effect.Effect<ListRunnersResult, ClientError>;
+    readonly routeExecution: (executionId: Ids.ExecutionId) => Effect.Effect<RouteExecutionResult, ClientError>;
     readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError>;
-    readonly streamExecution: (input: Operation.StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError>;
-    readonly wake: (input: Operation.WakeInput) => Effect.Effect<Operation.WakeAccepted, ClientError>;
-    readonly listPendingApprovals: (input: Operation.ListPendingApprovalsInput) => Effect.Effect<Operation.PendingToolApprovalList, ClientError>;
-    readonly resolveToolApproval: (input: Operation.ResolveToolApprovalInput) => Effect.Effect<Operation.WakeAccepted, ClientError>;
-    readonly resolvePermission: (input: Operation.ResolvePermissionInput) => Effect.Effect<Operation.WakeAccepted, ClientError>;
-    readonly submitInboundEnvelope: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, ClientError>;
+    readonly streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError>;
+    readonly wake: (input: WakeInput) => Effect.Effect<WakeAccepted, ClientError>;
+    readonly listPendingApprovals: (input: ListPendingApprovalsInput) => Effect.Effect<PendingToolApprovalList, ClientError>;
+    readonly resolveToolApproval: (input: ResolveToolApprovalInput) => Effect.Effect<WakeAccepted, ClientError>;
+    readonly resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, ClientError>;
+    readonly submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError>;
     readonly spawnChildRun: (input: Execution.SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError>;
-    readonly claimEnvelopeReady: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, ClientError>;
-    readonly ackEnvelopeReady: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, ClientError>;
-    readonly releaseEnvelopeReady: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, ClientError>;
-    readonly createSchedule: (input: Operation.CreateScheduleInput) => Effect.Effect<Operation.CreateScheduleResult, ClientError>;
-    readonly cancelSchedule: (input: Operation.CancelScheduleInput) => Effect.Effect<Operation.CancelScheduleResult, ClientError>;
-    readonly listSchedules: (input: Operation.ListSchedulesInput) => Effect.Effect<Operation.ListSchedulesResult, ClientError>;
+    readonly claimEnvelopeReady: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError>;
+    readonly ackEnvelopeReady: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError>;
+    readonly releaseEnvelopeReady: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError>;
+    readonly createSchedule: (input: CreateScheduleInput) => Effect.Effect<CreateScheduleResult, ClientError>;
+    readonly cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<CancelScheduleResult, ClientError>;
+    readonly listSchedules: (input: ListSchedulesInput) => Effect.Effect<ListSchedulesResult, ClientError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/Client", Interface>;
 export declare class Service extends Service_base {
@@ -113,88 +84,6 @@ export declare const layerFromRuntime: Layer.Layer<Service, never, AgentRegistry
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
 export declare const registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
-export declare const agent: (slug: string, input: AgentOptions) => Effect.Effect<{
-    id: string & import("effect/Brand").Brand<"Relay.AgentId">;
-    address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
-    record: {
-        readonly id: string & import("effect/Brand").Brand<"Relay.AgentId">;
-        readonly created_at: number;
-        readonly updated_at: number;
-        readonly current_revision: number;
-        readonly definition: {
-            readonly name: string;
-            readonly permissions: readonly {
-                readonly name: string;
-                readonly value: Schema.Json;
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-            }[];
-            readonly model: {
-                readonly provider: string;
-                readonly model: string;
-                readonly metadata?: {
-                    readonly [x: string]: Schema.Json;
-                };
-                readonly registration_key?: string;
-                readonly request_options?: {
-                    readonly [x: string]: Schema.Json;
-                };
-            };
-            readonly tool_names: readonly string[];
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-            readonly instructions?: string;
-            readonly output_schema_ref?: string;
-            readonly skill_definition_ids?: readonly (string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">)[];
-            readonly permission_rules?: {
-                readonly rules: readonly {
-                    readonly pattern: string;
-                    readonly level: "allow" | "deny" | "ask";
-                    readonly reason?: string;
-                }[];
-                readonly fallback?: "allow" | "deny" | "ask";
-            };
-            readonly max_tool_turns?: number;
-            readonly max_wait_turns?: number;
-            readonly token_budget?: number;
-            readonly child_run_presets?: {
-                readonly [x: string]: {
-                    readonly metadata?: {
-                        readonly [x: string]: Schema.Json;
-                    };
-                    readonly permissions?: readonly string[];
-                    readonly model?: {
-                        readonly provider: string;
-                        readonly model: string;
-                        readonly metadata?: {
-                            readonly [x: string]: Schema.Json;
-                        };
-                        readonly registration_key?: string;
-                        readonly request_options?: {
-                            readonly [x: string]: Schema.Json;
-                        };
-                    };
-                    readonly instructions?: string;
-                    readonly tool_names?: readonly string[];
-                    readonly workspace_policy?: {
-                        readonly mode: "share" | "fork";
-                        readonly fallback?: "fail" | "fresh";
-                    };
-                    readonly output_schema_ref?: string;
-                };
-            };
-            readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
-                readonly name: Schema.String;
-                readonly preset_name: Schema.String;
-            }, "Type">[];
-        };
-        readonly tool_input_schema_digests?: {
-            readonly [x: string]: string;
-        };
-    };
-}, ClientError, Service>;
 export declare const getAgentDefinition: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError, Service>;
 export declare const listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError, Service>;
 export declare const listAgentDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
@@ -204,33 +93,31 @@ export declare const listSkillDefinitionRevisions: (id: string & import("effect/
 export declare const registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError, Service>;
 export declare const getAddressBookRoute: (id: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Address.RouteRecord | undefined, ClientError, Service>;
 export declare const listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError, Service>;
-export declare const startExecution: (input: Operation.StartExecutionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
-export declare const startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
-export declare const startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
-export declare const start: (target: StartTarget, input?: StartInput | undefined) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
-export declare const run: (target: StartTarget, input?: RunInput) => Stream.Stream<Execution.ExecutionEvent, ClientError, Service>;
-export declare const cancelExecution: (input: Operation.CancelExecutionInput) => Effect.Effect<Operation.CancelExecutionAccepted, ClientError, Service>;
-export declare const steer: (input: Operation.SteerInput) => Effect.Effect<Operation.SteerAccepted, ClientError, Service>;
+export declare const startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, ClientError, Service>;
+export declare const startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, ClientError, Service>;
+export declare const startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, ClientError, Service>;
+export declare const cancelExecution: (input: CancelExecutionInput) => Effect.Effect<CancelExecutionAccepted, ClientError, Service>;
+export declare const steer: (input: SteerInput) => Effect.Effect<SteerAccepted, ClientError, Service>;
 export declare const getExecution: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Execution.Execution | undefined, ClientError, Service>;
-export declare const listExecutions: (input: Operation.ListExecutionsInput) => Effect.Effect<Operation.ListExecutionsResult, ClientError, Service>;
-export declare const listSessions: (input: Operation.ListSessionsInput) => Effect.Effect<Operation.ListSessionsResult, ClientError, Service>;
-export declare const getSession: (input: Operation.GetSessionInput) => Effect.Effect<Operation.GetSessionResult, ClientError, Service>;
-export declare const listWaits: (input: Operation.ListWaitsInput) => Effect.Effect<readonly Operation.WaitView[], ClientError, Service>;
-export declare const replayExecution: (input: Operation.ReplayExecutionInput) => Effect.Effect<Operation.ReplayExecutionResult, ClientError, Service>;
-export declare const listRunners: () => Effect.Effect<Operation.ListRunnersResult, ClientError, Service>;
-export declare const routeExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Operation.RouteExecutionResult, ClientError, Service>;
+export declare const listExecutions: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ClientError, Service>;
+export declare const listSessions: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, ClientError, Service>;
+export declare const getSession: (input: GetSessionInput) => Effect.Effect<GetSessionResult, ClientError, Service>;
+export declare const listWaits: (input: ListWaitsInput) => Effect.Effect<readonly WaitView[], ClientError, Service>;
+export declare const replayExecution: (input: ReplayExecutionInput) => Effect.Effect<ReplayExecutionResult, ClientError, Service>;
+export declare const listRunners: () => Effect.Effect<ListRunnersResult, ClientError, Service>;
+export declare const routeExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<RouteExecutionResult, ClientError, Service>;
 export declare const send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError, Service>;
-export declare const streamExecution: (input: Operation.StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError, Service>;
-export declare const wake: (input: Operation.WakeInput) => Effect.Effect<Operation.WakeAccepted, ClientError, Service>;
-export declare const listPendingApprovals: (input: Operation.ListPendingApprovalsInput) => Effect.Effect<Operation.PendingToolApprovalList, ClientError, Service>;
-export declare const resolveToolApproval: (input: Operation.ResolveToolApprovalInput) => Effect.Effect<Operation.WakeAccepted, ClientError, Service>;
-export declare const resolvePermission: (input: Operation.ResolvePermissionInput) => Effect.Effect<Operation.WakeAccepted, ClientError, Service>;
-export declare const submitInboundEnvelope: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, ClientError, Service>;
+export declare const streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError, Service>;
+export declare const wake: (input: WakeInput) => Effect.Effect<WakeAccepted, ClientError, Service>;
+export declare const listPendingApprovals: (input: ListPendingApprovalsInput) => Effect.Effect<PendingToolApprovalList, ClientError, Service>;
+export declare const resolveToolApproval: (input: ResolveToolApprovalInput) => Effect.Effect<WakeAccepted, ClientError, Service>;
+export declare const resolvePermission: (input: ResolvePermissionInput) => Effect.Effect<WakeAccepted, ClientError, Service>;
+export declare const submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError, Service>;
 export declare const spawnChildRun: (input: Execution.SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError, Service>;
-export declare const claimEnvelopeReady: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, ClientError, Service>;
-export declare const ackEnvelopeReady: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, ClientError, Service>;
-export declare const releaseEnvelopeReady: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, ClientError, Service>;
-export declare const createSchedule: (input: Operation.CreateScheduleInput) => Effect.Effect<Operation.CreateScheduleResult, ClientError, Service>;
-export declare const cancelSchedule: (input: Operation.CancelScheduleInput) => Effect.Effect<Operation.CancelScheduleResult, ClientError, Service>;
-export declare const listSchedules: (input: Operation.ListSchedulesInput) => Effect.Effect<Operation.ListSchedulesResult, ClientError, Service>;
+export declare const claimEnvelopeReady: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError, Service>;
+export declare const ackEnvelopeReady: (input: AckEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyAcked, ClientError, Service>;
+export declare const releaseEnvelopeReady: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError, Service>;
+export declare const createSchedule: (input: CreateScheduleInput) => Effect.Effect<CreateScheduleResult, ClientError, Service>;
+export declare const cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<CancelScheduleResult, ClientError, Service>;
+export declare const listSchedules: (input: ListSchedulesInput) => Effect.Effect<ListSchedulesResult, ClientError, Service>;
 export {};

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

@@ -1,14 +1,15 @@
-import * as StoreSql from "../store-sql/index";
-export type Drizzle = StoreSql.Database.Drizzle;
-export type PgTimestamp = StoreSql.Database.PgTimestamp;
-export type DatabaseError = StoreSql.Database.DatabaseError;
-export type Dialect = StoreSql.Database.Dialect;
-export declare const Service: typeof StoreSql.Database.Service;
-export declare const layerFromPgClient: import("effect/Layer").Layer<StoreSql.Database.Service, never, import("@effect/sql-pg/PgClient").PgClient>;
-export declare const testLayer: (db: StoreSql.Database.Drizzle) => import("effect/Layer").Layer<StoreSql.Database.Service, never, never>;
-export declare const check: () => import("effect/Effect").Effect<void, import("drizzle-orm/effect-core").EffectDrizzleQueryError, StoreSql.Database.Service>;
+import { Database } from "../store-sql/index";
+import type { Context, Effect } from "effect";
+export type Drizzle = Context.Service.Shape<typeof Database.Service>;
+export type PgTimestamp = Parameters<typeof Database.fromPgDate>[0];
+export type DatabaseError = Effect.Error<ReturnType<typeof Database.check>>;
+export type Dialect = typeof Database.Dialect.Type;
+export declare const Service: typeof Database.Service;
+export declare const layerFromPgClient: import("effect/Layer").Layer<Database.Service, never, import("@effect/sql-pg/PgClient").PgClient>;
+export declare const testLayer: (db: Database.Drizzle) => import("effect/Layer").Layer<Database.Service, never, never>;
+export declare const check: () => Effect.Effect<void, import("drizzle-orm/effect-core").EffectDrizzleQueryError, Database.Service>;
 export declare const pgTypeParsers: {
     getTypeParser: (typeId: number, format?: "text" | "binary") => any;
 };
 export declare const Dialect: import("effect/Schema").Literals<readonly ["pg", "mysql", "sqlite"]>;
-export declare const dialect: import("effect/Effect").Effect<"pg" | "mysql" | "sqlite", never, import("effect/unstable/sql/SqlClient").SqlClient>;
+export declare const dialect: Effect.Effect<"pg" | "mysql" | "sqlite", never, import("effect/unstable/sql/SqlClient").SqlClient>;

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

@@ -61,11 +61,11 @@ export declare const StartExecutionInput: Schema.Struct<{
     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.AgentId"> & {
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
-    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+    readonly agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -120,7 +120,7 @@ export declare const StartExecutionInput: Schema.Struct<{
         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 agent_definition_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     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">;
     }>;
@@ -942,7 +942,7 @@ export declare const ConversationSummary: Schema.Struct<{
     }>;
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
     readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
     readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
@@ -964,7 +964,7 @@ export declare const ListExecutionsResult: Schema.Struct<{
         }>;
         readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
         readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
-        readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
         }>;
         readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
@@ -1046,7 +1046,7 @@ export declare const GetSessionResult: Schema.Struct<{
         }>;
         readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
         readonly kind: Schema.Literals<readonly ["user-agent", "agent-agent"]>;
-        readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
         }>;
         readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;

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

@@ -1,7 +1,7 @@
 import { Ids } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as AddressBook from "./address-book-service";
-import * as AgentRegistry from "../agent/agent-registry-service";
+import { Service as AddressBookService } from "./address-book-service";
+import { Service as AgentRegistryService } from "../agent/agent-registry-service";
 declare const AddressRouteNotFound_base: Schema.Class<AddressRouteNotFound, Schema.TaggedStruct<"AddressRouteNotFound", {
     readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
@@ -23,7 +23,7 @@ declare const AddressAgentDefinitionNotFound_base: Schema.Class<AddressAgentDefi
     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 agent_definition_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+    readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     };
 }>, import("effect/Cause").YieldableError>;
@@ -50,11 +50,11 @@ export declare const LocalAgentTarget: Schema.Struct<{
         readonly route_key: Schema.String;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>;
-    readonly agent_definition_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+    readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     };
-    readonly agent_definition_revision: Schema.Int;
-    readonly agent_definition_snapshot: Schema.Struct<{
+    readonly agent_revision: Schema.Int;
+    readonly agent_snapshot: Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -119,7 +119,7 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AddressResolution", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, AddressBook.Service | AgentRegistry.Service>;
+export declare const layer: Layer.Layer<Service, never, AddressBookService | AgentRegistryService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const resolveLocalAgent: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<LocalAgentTarget, AddressRouteNotFound | AddressRouteKindMismatch | AddressAgentDefinitionNotFound | AddressResolutionError, Service>;
 export {};

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

@@ -1,15 +1,15 @@
 import { Agent, Content, Execution, Ids, Shared, Tool } from "../../schema/index";
 import { AgentChatRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Ai from "effect/unstable/ai";
-import * as SpawnChildRunTool from "../child/spawn-child-run-tool";
-import * as EventLog from "../execution/event-log-service";
-import * as LanguageModelService from "../model/language-model-service";
-import * as ModelCallPolicy from "../model/model-call-policy";
-import * as SchemaRegistry from "../schema-registry/schema-registry-service";
-import * as ToolRuntime from "../tool/tool-runtime-service";
-import * as PromptAssembler from "./prompt-assembler-service";
-import * as RelayCompaction from "./relay-compaction";
+import { Tool as AiTool } from "effect/unstable/ai";
+import type { DispatchInput } from "../child/spawn-child-run-tool";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { Service as LanguageModelServiceService } from "../model/language-model-service";
+import { Service as ModelCallPolicyService } from "../model/model-call-policy";
+import { Service as SchemaRegistryService } from "../schema-registry/schema-registry-service";
+import { Service as ToolRuntimeService } from "../tool/tool-runtime-service";
+import { Service as PromptAssemblerService } from "./prompt-assembler-service";
+import type { Options } from "./relay-compaction";
 declare const AgentLoopError_base: Schema.Class<AgentLoopError, Schema.TaggedStruct<"AgentLoopError", {
     readonly message: Schema.String;
     readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
@@ -44,8 +44,8 @@ export interface RunInput {
     readonly sessionId?: Ids.SessionId;
     readonly agent: Agent.Definition;
     readonly agentId?: Ids.AgentId;
-    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly agentRevision?: Agent.DefinitionRevision;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly input: ReadonlyArray<Content.Part>;
     readonly resumeToolCall?: Tool.Call;
     readonly memorySubjectId?: Ids.MemorySubjectId;
@@ -54,9 +54,9 @@ export interface RunInput {
     readonly completedAt: number;
     readonly steeringEnabled?: boolean;
     readonly toolOutputMaxBytes?: number | null;
-    readonly compaction?: RelayCompaction.Options | null;
+    readonly compaction?: Options | null;
     readonly sessionEntryScope?: string;
-    readonly dispatchChildRun?: (input: SpawnChildRunTool.DispatchInput) => Effect.Effect<void, unknown, any>;
+    readonly dispatchChildRun?: (input: DispatchInput) => Effect.Effect<void, unknown, any>;
 }
 export interface RunResult {
     readonly metadata: Shared.Metadata;
@@ -76,10 +76,10 @@ export declare class Service extends Service_base {
  * @experimental
  */
 export declare const STRUCTURED_TURN_PROMPT = "Return the final structured output for the task above.";
-export declare const toolFromDefinition: (definition: Tool.Definition) => Ai.Tool.Any;
+export declare const toolFromDefinition: (definition: Tool.Definition) => AiTool.Any;
 /** Map a Baton run failure (or an upstream model error) to the public error types. */
 export declare const mapBoundaryError: (error: unknown, current: Execution.ExecutionEventSequence) => AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
-export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLog.Service | ToolRuntime.Service | LanguageModelService.Service | ModelCallPolicy.Service | SchemaRegistry.Service | PromptAssembler.Service>;
+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 {};