@relayfx/sdk 0.0.38 → 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.AgentDefinitionId;
+    readonly agent_id: Ids.AgentId;
     readonly input?: ReadonlyArray<Content.Part>;
     readonly idempotency_key: Shared.NonEmptyString;
     readonly execution_id?: Ids.ExecutionId;
@@ -40,42 +40,42 @@ export interface RegisterAgentInput extends Agent.DefineInput {
 export interface Interface {
     readonly registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
-    readonly getAgentDefinition: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
+    readonly getAgentDefinition: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
     readonly listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError>;
-    readonly listAgentDefinitionRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRevisionList, ClientError>;
+    readonly listAgentDefinitionRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, ClientError>;
     readonly getSkillDefinition: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError>;
     readonly listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError>;
     readonly listSkillDefinitionRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRevisionList, ClientError>;
     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 {
@@ -84,40 +84,40 @@ 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 getAgentDefinition: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRecord | undefined, 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.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
+export declare const listAgentDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
 export declare const getSkillDefinition: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError, Service>;
 export declare const listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError, Service>;
 export declare const listSkillDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">) => Effect.Effect<Skill.DefinitionRevisionList, ClientError, Service>;
 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 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.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    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,8 +942,8 @@ 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.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    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>>;
     readonly created_at: Schema.Int;
@@ -964,8 +964,8 @@ 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.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        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>>;
         readonly created_at: Schema.Int;
@@ -1046,8 +1046,8 @@ 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.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        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>>;
         readonly created_at: Schema.Int;

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,8 +23,8 @@ 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.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    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>;
 export declare class AddressAgentDefinitionNotFound extends AddressAgentDefinitionNotFound_base {
@@ -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.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    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>;
@@ -43,9 +43,9 @@ export interface RunInput {
     readonly executionId: Ids.ExecutionId;
     readonly sessionId?: Ids.SessionId;
     readonly agent: Agent.Definition;
-    readonly agentDefinitionId?: Ids.AgentDefinitionId;
-    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly agentId?: Ids.AgentId;
+    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,29 +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.";
-/**
- * Converts a Relay `Tool.Definition` into the `Ai.Tool` Baton's toolkit
- * consumes. Exported for direct unit testing of the `needsApproval` mapping
- * (see `agent-loop-service.test.ts`) — `Tool.Definition.needs_approval` must
- * reach the constructed tool honestly so Relay tools self-describe correctly
- * even outside Relay's own durable approval gate (docs/spec/27).
- *
- * @experimental
- */
-/**
- * Build the model-facing `Ai.Tool` from a bare `Tool.Definition`, delegating to
- * the single canonical mapping in `ToolRuntime` so the parameters schema is a real
- * object AST (not the `Schema.Unknown` placeholder that breaks OpenRouter/Anthropic
- * tool preparation). Retained and exported only for the unit tests that assert the
- * `needs_approval` mapping; the run loop builds its toolkit from `RegisteredTool`s
- * (which may carry a tool's own concrete `aiTool`), not from definitions.
- *
- * @experimental
- */
-export declare const aiToolFromDefinition: (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 {};

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

@@ -13,10 +13,10 @@ export declare class AgentRegistryError extends AgentRegistryError_base {
 }
 export interface Interface {
     readonly register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError>;
-    readonly get: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError>;
+    readonly get: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError>;
     readonly getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError>;
     readonly list: () => Effect.Effect<Agent.DefinitionList, AgentRegistryError>;
-    readonly listRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError>;
+    readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AgentRegistry", Interface>;
 export declare class Service extends Service_base {
@@ -24,8 +24,8 @@ export declare class Service extends Service_base {
 export declare const layer: Layer.Layer<Service, never, AgentDefinitionRepository.Service>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError, Service>;
-export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError, Service>;
 export declare const getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError, Service>;
 export declare const list: () => Effect.Effect<Agent.DefinitionList, AgentRegistryError, Service>;
-export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError, Service>;
+export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError, Service>;
 export {};

package/dist/types/runtime/agent/prompt-assembler-service.d.ts

@@ -1,70 +1,32 @@
 import { Agent, Content, Shared, Tool } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Ai from "effect/unstable/ai";
-import * as ArtifactStore from "../content/artifact-store-service";
-import * as BlobStore from "../content/blob-store-service";
+import { Prompt } from "effect/unstable/ai";
+import { Service as ArtifactStoreService } from "../content/artifact-store-service";
+import { Service as BlobStoreService } from "../content/blob-store-service";
 declare const PromptAssemblerError_base: Schema.Class<PromptAssemblerError, Schema.TaggedStruct<"PromptAssemblerError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/**
- * @experimental
- */
 export declare class PromptAssemblerError extends PromptAssemblerError_base {
 }
-/**
- * Everything an assembler may consider when building the turn-zero prompt.
- *
- * @experimental
- */
 export interface AssembleInput {
     readonly agent: Agent.Definition;
     readonly tools: ReadonlyArray<Tool.Definition>;
     readonly input: ReadonlyArray<Content.Part>;
-    /**
-     * Reserved truncation hook: when set, the assembler SHOULD keep the
-     * assembled prompt within this many tokens. The default layer ignores it
-     * (no tokenizer implementation exists yet); summarization/memory layers
-     * implement it later. Interface-only in v1.
-     */
     readonly tokenBudget?: number;
     readonly metadata?: Shared.Metadata;
 }
-/**
- * @experimental
- */
 export interface Assembled {
-    /** Content of the system message the chat is seeded with. */
     readonly system: string;
-    /** The turn-zero prompt (typically one user message built from `input`). */
-    readonly prompt: Ai.Prompt.Prompt;
+    readonly prompt: Prompt.Prompt;
 }
-/**
- * @experimental
- */
 export interface Interface {
     readonly assemble: (input: AssembleInput) => Effect.Effect<Assembled, PromptAssemblerError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/PromptAssembler", Interface>;
-/**
- * @experimental
- */
 export declare class Service extends Service_base {
 }
-/**
- * Content parts whose conversion is pure — everything except the reference
- * parts (`blob-reference`, `artifact-reference`), which are resolved
- * effectfully through {@link BlobStore} / {@link ArtifactStore}.
- *
- * @experimental
- */
 export type PureContentPart = Content.TextPart | Content.StructuredPart | Content.ToolCallPart | Content.ToolResultPart;
-/**
- * Converts a pure Relay content part into an Effect AI user-message prompt part.
- * Reference parts are resolved separately (see the default layer).
- *
- * @experimental
- */
-export declare const contentToPromptPart: (part: PureContentPart) => Ai.Prompt.UserMessagePart;
+export declare const contentToPromptPart: (part: PureContentPart) => Prompt.UserMessagePart;
 /**
  * Default assembler that resolves reference content parts through the
  * {@link BlobStore} and {@link ArtifactStore} it reads from context. Requires
@@ -73,7 +35,7 @@ export declare const contentToPromptPart: (part: PureContentPart) => Ai.Prompt.U
  *
  * @experimental
  */
-export declare const defaultLayerWithStores: Layer.Layer<Service, never, BlobStore.Service | ArtifactStore.Service>;
+export declare const defaultLayerWithStores: Layer.Layer<Service, never, BlobStoreService | ArtifactStoreService>;
 /**
  * Default assembler: reproduces the agent loop's historical prompt construction,
  * minus the model-selection dump (see `docs/spec/28-prompt-assembly.md`).

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

@@ -1,21 +1,2 @@
 import { Approvals } from "@batonfx/core";
-/**
- * Relay's binding for Baton's `Approvals` seam: a DELIBERATE, PERMANENT
- * auto-approving pass-through, not a placeholder.
- *
- * Decision authority for `needs_approval` tools lives one seam downstream, in
- * the durable `ToolRuntime.run` gate (docs/spec/27-tool-approvals.md) — a
- * deterministic `wait:approval:${tool_call_id}` row plus
- * `tool.approval.requested` / `tool.approval.resolved` events. Baton dispatches
- * a `needsApproval` tool call to `Approvals.check` first and, on `Approved`,
- * hands off to `ToolExecutor.execute` (`RelayToolExecutor`, wrapping
- * `ToolRuntime.run`) — where the REAL gate runs and suspends the call via
- * Baton's `Suspend` outcome (`ToolExecutionWaitRequested`) until a decision is
- * recorded. Auto-approving here just clears Baton's own pre-execution check so
- * every call reaches that durable gate; it does not skip approval enforcement.
- * Moving the gate into `Approvals.check` instead would change the durable
- * event order that `test/e2e/tool-approval-durability.e2e.test.ts` depends on.
- *
- * @experimental
- */
 export declare const layer: import("effect/Layer").Layer<Approvals.Approvals, never, never>;