@relayfx/test 0.2.14 → 0.2.16

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

@@ -59,15 +59,15 @@ export interface Interface {
     readonly resolve: (addressId: Ids.AddressId) => Effect.Effect<Route, AddressNotFound | AddressUnavailable | AddressDeferred | AddressBookServiceError>;
     readonly register: (addressId: Ids.AddressId, route: Route) => Effect.Effect<Address.RouteRegistered, AddressBookServiceError>;
     readonly get: (addressId: Ids.AddressId) => Effect.Effect<RouteRecord | undefined, AddressBookServiceError>;
-    readonly list: () => Effect.Effect<Address.RouteList, AddressBookServiceError>;
+    readonly list: Effect.Effect<Address.RouteList, AddressBookServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AddressBook", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/address/address-book-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layerFromRepository: Layer.Layer<Service, never, AddressBookRepository.Service>;
 export declare const memoryLayer: (entries?: Iterable<readonly [Ids.AddressId, Route]>) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const resolve: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Route, AddressNotFound | AddressUnavailable | AddressDeferred | AddressBookServiceError, Service>;
+export declare const resolve: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Route, AddressBookServiceError | AddressDeferred | AddressNotFound | AddressUnavailable, Service>;
 export declare const register: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">, route: Route) => Effect.Effect<Address.RouteRegistered, AddressBookServiceError, Service>;
 export declare const get: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<RouteRecord | undefined, AddressBookServiceError, Service>;
 export declare const list: () => Effect.Effect<Address.RouteList, AddressBookServiceError, Service>;

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

@@ -56,83 +56,105 @@ export declare const LocalAgentTarget: Schema.Struct<{
     readonly agent_revision: Schema.Int;
     readonly agent_snapshot: Schema.Codec<Agent.Definition, {
         readonly name: string;
-        readonly permissions: readonly {
-            readonly name: string;
-            readonly value: Schema.Json;
-            readonly metadata?: {
-                readonly [x: string]: Schema.Json;
-            };
-        }[];
+        readonly instructions?: 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 metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
         };
         readonly tool_names: readonly string[];
-        readonly metadata?: {
-            readonly [x: string]: Schema.Json;
-        };
-        readonly instructions?: string;
-        readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-            readonly context_window: Schema.Number;
-            readonly reserve_tokens: Schema.Number;
-            readonly keep_recent_tokens: Schema.Number;
-        }, "Encoded">;
-        readonly output_schema_ref?: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
         readonly skill_definition_ids?: readonly string[];
         readonly permission_rules?: {
             readonly rules: readonly {
                 readonly pattern: string;
-                readonly level: "allow" | "deny" | "ask";
+                readonly level: "allow" | "ask" | "deny";
                 readonly reason?: string;
             }[];
-            readonly fallback?: "allow" | "deny" | "ask";
+            readonly fallback?: "allow" | "ask" | "deny";
         };
         readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly compaction_policy?: {
+            readonly context_window: number;
+            readonly reserve_tokens: number;
+            readonly keep_recent_tokens: number;
+            readonly summary_model?: {
+                readonly provider: string;
+                readonly model: string;
+                readonly registration_key?: string;
+                readonly request_options?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+            };
+        };
         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 instructions?: 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 metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly compaction_policy?: {
+                    readonly context_window: number;
+                    readonly reserve_tokens: number;
+                    readonly keep_recent_tokens: number;
+                    readonly summary_model?: {
+                        readonly provider: string;
+                        readonly model: string;
+                        readonly registration_key?: string;
+                        readonly request_options?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                        readonly metadata?: {
+                            readonly [x: string]: Schema.Json;
+                        };
+                    };
                 };
-                readonly instructions?: string;
-                readonly compaction_policy?: Schema.Struct.ReadonlySide<{
-                    readonly context_window: Schema.Number;
-                    readonly reserve_tokens: Schema.Number;
-                    readonly keep_recent_tokens: Schema.Number;
-                }, "Encoded">;
                 readonly tool_names?: readonly string[];
+                readonly permissions?: readonly string[];
                 readonly workspace_policy?: {
-                    readonly mode: "share" | "fork";
+                    readonly mode: "fork" | "share";
                     readonly fallback?: "fail" | "fresh";
                 };
                 readonly output_schema_ref?: string;
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
             };
         };
         readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
             readonly name: Schema.String;
             readonly preset_name: Schema.String;
         }, "Encoded">[];
+        readonly output_schema_ref?: string;
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
     }, never, never>;
     readonly tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
 }>;
@@ -141,10 +163,10 @@ export interface LocalAgentTarget extends Schema.Schema.Type<typeof LocalAgentTa
 export interface Interface {
     readonly resolveLocalAgent: (addressId: Ids.AddressId) => Effect.Effect<LocalAgentTarget, AddressRouteNotFound | AddressRouteKindMismatch | AddressAgentDefinitionNotFound | AddressResolutionError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AddressResolution", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/address/address-resolution-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 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 declare const resolveLocalAgent: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<LocalAgentTarget, AddressAgentDefinitionNotFound | AddressResolutionError | AddressRouteKindMismatch | AddressRouteNotFound, Service>;
 export {};

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

@@ -8,6 +8,7 @@ import { Service as LanguageModelServiceService } from "../model/language-model-
 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 type { ToolRuntimeError } from "../tool/tool-runtime-service";
 import { Service as PromptAssemblerService } from "./prompt-assembler-service";
 declare const AgentLoopError_base: Schema.Class<AgentLoopError, Schema.TaggedStruct<"AgentLoopError", {
     readonly message: Schema.String;
@@ -54,7 +55,7 @@ export interface RunInput {
     readonly steeringEnabled?: boolean;
     readonly toolOutputMaxBytes?: number | null;
     readonly sessionEntryScope?: string;
-    readonly dispatchChildRun?: (input: DispatchInput) => Effect.Effect<void, unknown, any>;
+    readonly dispatchChildRun?: (input: DispatchInput) => Effect.Effect<void, ToolRuntimeError>;
 }
 export interface RunResult {
     readonly metadata: Shared.Metadata;
@@ -63,7 +64,7 @@ export interface RunResult {
 export interface Interface {
     readonly run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AgentLoop", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/agent/agent-loop-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 /**
@@ -74,10 +75,18 @@ 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) => AiTool.Any;
+export declare const toolFromDefinition: (definition: Tool.Definition) => AiTool.Dynamic<string, {
+    readonly parameters: Schema.Codec<unknown, unknown, never, never>;
+    readonly success: Schema.Unknown;
+    readonly failure: Schema.Never;
+    readonly failureMode: "error";
+}, never>;
 /** 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 mapBoundaryError: {
+    (current: Execution.ExecutionEventSequence): (error: unknown) => AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
+    (error: unknown, current: Execution.ExecutionEventSequence): AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
+};
 export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLogService | ToolRuntimeService | LanguageModelServiceService | ModelCallPolicyService | SchemaRegistryService | PromptAssemblerService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopBudgetExceeded | AgentLoopWaitRequested, Service>;
+export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopBudgetExceeded | AgentLoopError | AgentLoopWaitRequested, Service>;
 export {};

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

@@ -15,10 +15,10 @@ export interface Interface {
     readonly register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | 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 list: Effect.Effect<Agent.DefinitionList, AgentRegistryError>;
     readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AgentRegistry", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/agent/agent-registry-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, AgentDefinitionRepository.Service>;

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

@@ -22,7 +22,7 @@ export interface Assembled {
 export interface Interface {
     readonly assemble: (input: AssembleInput) => Effect.Effect<Assembled, PromptAssemblerError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/PromptAssembler", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/agent/prompt-assembler-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export type PureContentPart = Content.TextPart | Content.StructuredPart | Content.ToolCallPart | Content.ToolResultPart;

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

@@ -1,11 +1,12 @@
-import { Compaction } from "@batonfx/core";
+import { Compaction, ModelRegistry } from "@batonfx/core";
 import { Ids } from "../../schema/index";
 import { CompactionRepository } from "@relayfx/store-sql/portable";
-import { Layer } from "effect";
+import { Effect, Layer } from "effect";
 export interface Options {
     readonly contextWindow?: number;
     readonly reserveTokens?: number;
     readonly keepRecentTokens?: number;
+    readonly summaryModel?: Effect.Effect<Layer.Layer<ModelRegistry.ModelEnvironment>, Compaction.CompactionError>;
 }
 export interface Config {
     readonly executionId: Ids.ExecutionId;

package/dist/types/runtime/agent/relay-tool-output.d.ts

@@ -1,7 +1,10 @@
 import { ToolOutput } from "@batonfx/core";
 import { Effect, Layer, Option } from "effect";
 import type { Interface as BlobStoreInterface, Service as BlobStoreService } from "../content/blob-store-service";
-export declare const store: (blobStore: BlobStoreInterface, toolCallId: string, content: unknown) => Effect.Effect<Option.Option<string>, ToolOutput.ToolOutputError>;
+export declare const store: {
+    (blobStore: BlobStoreInterface, toolCallId: string, content: unknown): Effect.Effect<Option.Option<string>, ToolOutput.ToolOutputError>;
+    (toolCallId: string, content: unknown): (blobStore: BlobStoreInterface) => Effect.Effect<Option.Option<string>, ToolOutput.ToolOutputError>;
+};
 export declare const make: (blobStore: BlobStoreInterface) => ToolOutput.StoreInterface;
 export declare const layerFromBlobStore: (blobStore: BlobStoreInterface) => Layer.Layer<ToolOutput.ToolOutputStore>;
 export declare const layer: Layer.Layer<ToolOutput.ToolOutputStore, never, BlobStoreService>;

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

@@ -18,7 +18,7 @@ export interface Interface {
     readonly recover: (input: AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
     readonly recoverAll: (inputFor: (fanOut: ChildOrchestration.FanOutState) => AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildFanOutAdmissionService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-fan-out-admission-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, ChildFanOutRepository.Service | ChildRunService>;

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

@@ -9,10 +9,14 @@ export interface ChildResult {
     readonly completedAt?: number;
 }
 export interface Handlers {
-    readonly execute: (child: ChildOrchestration.FanOutChild, fanOut: ChildOrchestration.FanOutState, idempotencyKey: string) => Effect.Effect<ChildResult, unknown>;
-    readonly cancel: (childExecutionId: Ids.ChildExecutionId, reason: string) => Effect.Effect<void, unknown>;
+    readonly execute: (child: ChildOrchestration.FanOutChild, fanOut: ChildOrchestration.FanOutState, idempotencyKey: string) => Effect.Effect<ChildResult, {
+        readonly _tag: string;
+    }>;
+    readonly cancel: (childExecutionId: Ids.ChildExecutionId, reason: string) => Effect.Effect<void, {
+        readonly _tag: string;
+    }>;
 }
-declare const HandlerService_base: Context.ServiceClass<HandlerService, "@relayfx/runtime/ChildFanOutRuntimeHandlers", Handlers>;
+declare const HandlerService_base: Context.ServiceClass<HandlerService, "@relayfx/runtime/child/child-fan-out-runtime/HandlerService", Handlers>;
 export declare class HandlerService extends HandlerService_base {
 }
 declare const ChildFanOutRuntimeError_base: Schema.Class<ChildFanOutRuntimeError, Schema.TaggedStruct<"ChildFanOutRuntimeError", {
@@ -22,15 +26,15 @@ export declare class ChildFanOutRuntimeError extends ChildFanOutRuntimeError_bas
 }
 export interface Interface {
     readonly create: (definition: ChildOrchestration.FanOutDefinition) => Effect.Effect<ChildOrchestration.FanOutState, ChildFanOutRuntimeError>;
-    readonly recover: () => Effect.Effect<ReadonlyArray<Ids.ChildFanOutId>, ChildFanOutRuntimeError>;
+    readonly recover: (_?: never) => Effect.Effect<ReadonlyArray<Ids.ChildFanOutId>, ChildFanOutRuntimeError>;
     readonly cancel: (fanOutId: Ids.ChildFanOutId, cancelledAt: number, reason: string) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRuntimeError>;
     readonly inspect: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRuntimeError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildFanOutRuntime", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-fan-out-runtime/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layerFromRuntime: Layer.Layer<Service, ChildFanOutRuntimeError, ChildFanOutRepository.Service | TransitionService | HandlerService>;
-export declare const layer: Layer.Layer<Service, ChildFanOutRuntimeError, ChildFanOutRepository.Service | TransitionService | HandlerService>;
+export declare const layerFromRuntime: Layer.Layer<Service, ChildFanOutRuntimeError, HandlerService | ChildFanOutRepository.Service | TransitionService>;
+export declare const layer: Layer.Layer<Service, ChildFanOutRuntimeError, HandlerService | ChildFanOutRepository.Service | TransitionService>;
 export declare const handlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
-export declare const testHandlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
+export declare const testHandlersLayer: typeof handlersLayer;
 export {};

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

@@ -17,7 +17,7 @@ export interface TerminalInput {
 export interface Interface {
     readonly terminal: (input: TerminalInput) => Effect.Effect<ChildFanOutRepository.RecordTerminalResult | undefined, ChildFanOutTransitionError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildFanOutTransitionService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-fan-out-transition-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, ChildFanOutRepository.Service | EventLogService>;

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

@@ -70,7 +70,7 @@ export interface Interface {
     readonly spawnStatic: (input: SpawnStaticInput) => Effect.Effect<Execution.ChildRunAccepted, StaticChildRunPresetNotFound | ChildRunScopeBroadened | ChildRunWorkspaceUnavailable | ChildRunServiceError>;
     readonly spawnDynamic: (input: SpawnDynamicInput) => Effect.Effect<Execution.ChildRunAccepted, ChildRunScopeBroadened | ChildRunWorkspaceUnavailable | ChildRunServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ChildRunService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-run-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export interface ResolvedChildContext {
@@ -86,8 +86,11 @@ export interface ResolvedChildContext {
 export declare const layer: Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLogService>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const resolveForDispatch: (input: Execution.SpawnChildRunInput) => Effect.Effect<ResolvedChildContext, StaticChildRunPresetNotFound | ChildRunScopeBroadened, never>;
-export declare const childDefinition: (parentDefinition: Agent.Definition, context: ResolvedChildContext) => Effect.Effect<Agent.Definition, ChildRunModelMissing>;
-export declare const spawnStatic: (input: SpawnStaticInput) => Effect.Effect<Execution.ChildRunAccepted, StaticChildRunPresetNotFound | ChildRunScopeBroadened | ChildRunServiceError | ChildRunWorkspaceUnavailable, Service>;
+export declare const resolveForDispatch: (input: Execution.SpawnChildRunInput) => Effect.Effect<ResolvedChildContext, ChildRunScopeBroadened | StaticChildRunPresetNotFound, never>;
+export declare const childDefinition: {
+    (context: ResolvedChildContext): (parentDefinition: Agent.Definition) => Effect.Effect<Agent.Definition, ChildRunModelMissing>;
+    (parentDefinition: Agent.Definition, context: ResolvedChildContext): Effect.Effect<Agent.Definition, ChildRunModelMissing>;
+};
+export declare const spawnStatic: (input: SpawnStaticInput) => Effect.Effect<Execution.ChildRunAccepted, ChildRunScopeBroadened | ChildRunServiceError | ChildRunWorkspaceUnavailable | StaticChildRunPresetNotFound, Service>;
 export declare const spawnDynamic: (input: SpawnDynamicInput) => Effect.Effect<Execution.ChildRunAccepted, ChildRunScopeBroadened | ChildRunServiceError | ChildRunWorkspaceUnavailable, Service>;
 export {};

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

@@ -21,7 +21,7 @@ export interface NotifyInput {
 export interface Interface {
     readonly notify: (input: NotifyInput) => Effect.Effect<void, ParentNotifyError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ParentNotifier", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/parent-notifier-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export interface SignalParentWaitInput {
@@ -30,7 +30,9 @@ export interface SignalParentWaitInput {
     readonly signaledAt: number;
 }
 export interface MakeOptions {
-    readonly signalWait: (input: SignalParentWaitInput) => Effect.Effect<void, unknown>;
+    readonly signalWait: (input: SignalParentWaitInput) => Effect.Effect<void, {
+        readonly _tag: string;
+    }>;
 }
 export declare const make: (options: MakeOptions) => Effect.Effect<Interface, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;
 export declare const layerWith: (options: MakeOptions) => Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;

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

@@ -1,5 +1,6 @@
 import { Agent, Content, Execution, Ids, Shared } from "../../schema/index";
 import { Effect, Schema } from "effect";
+import { ToolRuntimeError } from "../tool/tool-runtime-service";
 import type { RegisteredTool } from "../tool/tool-runtime-service";
 import type { Interface as EventLogInterface } from "../execution/event-log-service";
 import type { Interface as WaitServiceInterface } from "../wait/wait-service";
@@ -17,9 +18,16 @@ export declare const Input: Schema.Struct<{
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>>;
     readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
-        readonly context_window: Schema.Number;
-        readonly reserve_tokens: Schema.Number;
-        readonly keep_recent_tokens: Schema.Number;
+        readonly context_window: Schema.Finite;
+        readonly reserve_tokens: Schema.Finite;
+        readonly keep_recent_tokens: Schema.Finite;
+        readonly summary_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>>;
@@ -209,7 +217,7 @@ export interface Config {
     readonly childRuns: ChildRunServiceInterface;
     readonly eventLog: EventLogInterface;
     readonly waits: WaitServiceInterface;
-    readonly dispatch: (input: DispatchInput) => Effect.Effect<void, unknown, any>;
+    readonly dispatch: (input: DispatchInput) => Effect.Effect<void, ToolRuntimeError>;
 }
 export declare const enabled: (agent: Agent.Definition) => boolean;
 export declare const registeredTool: (config: Config) => RegisteredTool;

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

@@ -34,6 +34,6 @@ export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
 }>, typeof ExecutionWorkflowFailed, never, never>;
 type ExecutionRpc = typeof Start | typeof Dispatch | typeof SignalWait | typeof Cancel;
 export declare const entity: Entity.Entity<"Relay/Execution", ExecutionRpc>;
-export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | WaitServiceService | ExecutionServiceService | ActiveExecutionRegistryService | ToolTransitionCoordinatorService | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
-export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<ExecutionRpc, import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | WaitServiceService | ExecutionServiceService | ActiveExecutionRegistryService | ToolTransitionCoordinatorService | import("effect/unstable/cluster/Sharding").Sharding | WorkflowEngine.WorkflowEngine>;
+export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<ExecutionRpc, import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;
 export {};

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

@@ -9,14 +9,14 @@ export declare class ArtifactNotResolvable extends ArtifactNotResolvable_base {
 export interface Interface {
     readonly resolve: (part: Content.ArtifactReferencePart) => Effect.Effect<ReadonlyArray<Content.Part>, ArtifactNotResolvable>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ArtifactStore", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/content/artifact-store-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const passthroughLayer: Layer.Layer<Service>;
 export interface MemoryInterface extends Interface {
     readonly register: (artifact_id: string, parts: ReadonlyArray<Content.Part>) => Effect.Effect<void>;
 }
-declare const Memory_base: Context.ServiceClass<Memory, "@relayfx/runtime/ArtifactStore/Memory", MemoryInterface>;
+declare const Memory_base: Context.ServiceClass<Memory, "@relayfx/runtime/content/artifact-store-service/Memory", MemoryInterface>;
 export declare class Memory extends Memory_base {
 }
 export declare const memoryLayer: Layer.Layer<Service | Memory>;

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

@@ -32,7 +32,7 @@ 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>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/content/blob-store-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const passthroughLayer: Layer.Layer<Service>;

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

@@ -56,12 +56,21 @@ export interface Interface {
         readonly limit?: number;
     }) => Effect.Effect<ReadonlyArray<Entity.Instance>, EntityServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EntityInstanceService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/entity/entity-instance-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const entityExecutionId: (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey, generation: number) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-export declare const entityAddressId: (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-export declare const entitySessionId: (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey) => string & import("effect/Brand").Brand<"Relay.SessionId">;
-export declare const layer: Layer.Layer<Service, never, EntityRepository.Service | AddressBookService | EventLogService | AgentRegistryService | import("effect/unstable/cluster/Sharding").Sharding | EntityRegistryService>;
+export declare const entityExecutionId: {
+    (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey, generation: number): Ids.ExecutionId;
+    (kind: Ids.EntityKindName, key: Ids.EntityKey, generation: number): (tenant: Ids.TenantId) => Ids.ExecutionId;
+};
+export declare const entityAddressId: {
+    (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey): Ids.AddressId;
+    (kind: Ids.EntityKindName, key: Ids.EntityKey): (tenant: Ids.TenantId) => Ids.AddressId;
+};
+export declare const entitySessionId: {
+    (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey): Ids.SessionId;
+    (kind: Ids.EntityKindName, key: Ids.EntityKey): (tenant: Ids.TenantId) => Ids.SessionId;
+};
+export declare const layer: Layer.Layer<Service, never, EntityRepository.Service | AddressBookService | EventLogService | AgentRegistryService | EntityRegistryService | import("effect/unstable/cluster/Sharding").Sharding>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export {};

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

@@ -25,9 +25,9 @@ export declare class EntityRegistryError extends EntityRegistryError_base {
 export interface Interface {
     readonly registerKind: (input: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, EntityKindInvalid | EntityRegistryError>;
     readonly getKind: (kind: Ids.EntityKindName) => Effect.Effect<Entity.KindDefinition | undefined, EntityRegistryError>;
-    readonly listKinds: () => Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRegistryError>;
+    readonly listKinds: Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRegistryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EntityRegistry", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/entity/entity-registry-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, EntityRepository.Service | AgentRegistryService>;

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

@@ -44,7 +44,7 @@ export interface Interface {
         readonly route_kind?: Route["kind"];
     }, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EnvelopeService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/envelope/envelope-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | AddressBookService | EventLogService>;
@@ -52,5 +52,5 @@ export declare const memoryLayer: (routes?: Iterable<readonly [Ids.AddressId, Ro
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted & {
     readonly route_kind?: Route["kind"];
-}, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError, Service>;
+}, EnvelopeAddressNotFound | EnvelopeRouteDeferred | EnvelopeRouteUnavailable | EnvelopeServiceError, Service>;
 export {};

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

@@ -4,7 +4,7 @@ export interface Interface {
     readonly run: <A, E, R>(executionId: Ids.ExecutionId, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
     readonly interrupt: (executionId: Ids.ExecutionId) => Effect.Effect<boolean>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ActiveExecutionRegistry", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/execution/active-execution-registry/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, never>;

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

@@ -48,13 +48,16 @@ export interface Interface {
     readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, EventLogError>;
     readonly sumUsage: (executionId: Ids.ExecutionId) => Effect.Effect<number, EventLogError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EventLog", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/execution/event-log-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layerFromRepository: Layer.Layer<Service, never, ExecutionEventRepository.Service>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const appendIdempotentTo: (eventLog: Interface, input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, never>;
+export declare const appendIdempotentTo: {
+    (eventLog: Interface, input: Execution.ExecutionEvent): Effect.Effect<Execution.ExecutionEvent, EventLogError>;
+    (input: Execution.ExecutionEvent): (eventLog: Interface) => Effect.Effect<Execution.ExecutionEvent, EventLogError>;
+};
 export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
 export declare const appendIdempotent: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
 export declare const replay: (input: ReplayInput) => Effect.Effect<readonly Execution.ExecutionEvent[], EventLogCursorNotFound | EventLogError, Service>;

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

@@ -51,7 +51,7 @@ export interface Interface {
     readonly spawnChildRun: (input: Execution.SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ExecutionServiceError>;
     readonly stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, ExecutionServiceError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ExecutionService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/execution/execution-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, ExecutionRepository.Service | EventLogService | ChildRunServiceService | ShardingConfig.ShardingConfig>;

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

@@ -23,7 +23,7 @@ export type ExecutionListChange = {
 export interface Interface {
     readonly watch: (input: WatchInput) => Stream.Stream<ExecutionListChange, ExecutionWatchError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ExecutionWatch", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/execution/execution-watch-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layerFromServices: Layer.Layer<Service, never, ExecutionRepository.Service>;

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

@@ -24,7 +24,7 @@ export type SessionStreamItem = {
 export interface Interface {
     readonly stream: (input: StreamInput) => Stream.Stream<SessionStreamItem, EventLogCursorNotFound | SessionStreamError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/SessionStream", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/execution/session-stream-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layerFromServices: Layer.Layer<Service, never, ExecutionRepository.Service | EventLogService>;

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

@@ -57,7 +57,7 @@ export interface Interface {
     readonly undrainedCount: (executionId: Ids.ExecutionId) => Effect.Effect<number, InboxServiceError>;
     readonly reply: (input: ReplyInput) => Effect.Effect<Envelope.EnvelopeAccepted, InboxReplyTokenInvalid | InboxDeliveryError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/InboxService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/inbox/inbox-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export interface SignalDependencies {

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

@@ -10,7 +10,7 @@ export interface Options {
 }
 export interface Interface extends Memory.Interface {
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/MemoryService", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/memory/memory-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: (options?: Options) => Layer.Layer<Service | Memory.Memory, never, MemoryRepository.Service | EmbeddingModelServiceService>;