@relayfx/sdk 0.0.38 → 0.0.40

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

@@ -4,19 +4,4 @@ export interface ContextEpoch {
     readonly dynamicSourceIds: ReadonlyArray<string>;
 }
 export declare const layerFromEpoch: (epoch: ContextEpoch) => import("effect/Layer").Layer<Instructions.Instructions, never, never>;
-/**
- * Delivers the assembled turn-zero system prompt through Baton's `Instructions`
- * seam instead of `Baton.Agent.RunOptions.system` (which makes Baton ignore its
- * `Instructions` registry entirely). Only the assembled SYSTEM STRING moves
- * through this seam — `PromptAssembler`'s blob/artifact prompt resolution has
- * no Baton equivalent and remains a permanent Relay responsibility
- * (docs/spec/28-prompt-assembly.md).
- *
- * Provided per-run, for fresh runs only: on resume, Baton ignores `Instructions`
- * once `RunOptions.history` is set (the durable transcript already carries the
- * assembled system message), so `agent-loop-service.ts` does not provide this
- * layer on the resume branch.
- *
- * @experimental
- */
 export declare const layer: (system: string) => import("effect/Layer").Layer<Instructions.Instructions, never, never>;

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

@@ -2,8 +2,8 @@ import { Permissions } from "@batonfx/core";
 import { Agent, Execution, Ids } from "../../schema/index";
 import { PermissionRuleRepository } from "../../store-sql/index";
 import { Effect, Layer } from "effect";
-import * as EventLog from "../execution/event-log-service";
-import * as WaitService from "../wait/wait-service";
+import type { Interface as EventLogInterface } from "../execution/event-log-service";
+import type { Interface as WaitServiceInterface } from "../wait/wait-service";
 export interface SequenceAllocator {
     readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
     readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
@@ -12,8 +12,8 @@ export interface SequenceAllocator {
 export interface Config {
     readonly ruleset: Agent.PermissionRuleset;
     readonly repository: PermissionRuleRepository.Interface;
-    readonly waits: WaitService.Interface;
-    readonly eventLog: EventLog.Interface;
+    readonly waits: WaitServiceInterface;
+    readonly eventLog: EventLogInterface;
     readonly allocator: SequenceAllocator;
     readonly executionId: Ids.ExecutionId;
     readonly agentName: string;

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

@@ -2,13 +2,13 @@ import { Steering } from "@batonfx/core";
 import { Execution, Ids } from "../../schema/index";
 import { SteeringRepository } from "../../store-sql/index";
 import { Effect, Layer } from "effect";
-import * as EventLog from "../execution/event-log-service";
+import type { Interface } from "../execution/event-log-service";
 export interface SequenceAllocator {
     readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
 }
 export interface Config {
     readonly repository: SteeringRepository.Interface;
-    readonly eventLog: EventLog.Interface;
+    readonly eventLog: Interface;
     readonly allocator: SequenceAllocator;
     readonly executionId: Ids.ExecutionId;
     readonly startedAt: number;

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

@@ -1,17 +1,11 @@
 import { ToolExecutor } from "@batonfx/core";
 import { Execution, Ids, Tool } from "../../schema/index";
 import { Effect, Layer } from "effect";
-import * as EventLog from "../execution/event-log-service";
-import * as ToolRuntime from "../tool/tool-runtime-service";
-/**
- * Per-run inputs the executor closes over. Mirrors the fields `runToolCall`
- * threaded before Baton owned the loop.
- *
- * @experimental
- */
+import type { Interface as ToolRuntimeInterface, RegisteredTool } from "../tool/tool-runtime-service";
+import type { Interface as EventLogInterface } from "../execution/event-log-service";
 export interface Config {
-    readonly toolRuntime: ToolRuntime.Interface;
-    readonly eventLog: EventLog.Interface;
+    readonly toolRuntime: ToolRuntimeInterface;
+    readonly eventLog: EventLogInterface;
     readonly allocator: {
         readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
         readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
@@ -22,17 +16,7 @@ export interface Config {
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly toolOutputMaxBytes?: number;
     readonly resumedToolCallId?: Ids.ToolCallId;
-    readonly extraTools?: ReadonlyArray<ToolRuntime.RegisteredTool>;
+    readonly extraTools?: ReadonlyArray<RegisteredTool>;
 }
-/**
- * Baton `ToolExecutor` over Relay's `ToolRuntime`. Allocates sequences and maps
- * errors; `ToolRuntime.run` itself appends `tool.call.requested` /
- * `tool.result.received` and enforces idempotency by `call.id`.
- *
- * @experimental
- */
 export declare const make: (config: Config) => ToolExecutor.Interface;
-/**
- * @experimental
- */
 export declare const layer: (config: Config) => Layer.Layer<ToolExecutor.ToolExecutor>;

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

@@ -1,7 +1,7 @@
 import { ToolOutput } from "@batonfx/core";
 import { Effect, Layer, Option } from "effect";
-import * as BlobStore from "../content/blob-store-service";
-export declare const store: (blobStore: BlobStore.Interface, toolCallId: string, content: unknown) => Effect.Effect<Option.Option<string>, ToolOutput.ToolOutputError>;
-export declare const make: (blobStore: BlobStore.Interface) => ToolOutput.StoreInterface;
-export declare const layerFromBlobStore: (blobStore: BlobStore.Interface) => Layer.Layer<ToolOutput.ToolOutputStore>;
-export declare const layer: Layer.Layer<ToolOutput.ToolOutputStore, never, BlobStore.Service>;
+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 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/agent/sequence-allocator.d.ts

@@ -1,27 +1,8 @@
 import { Execution } from "../../schema/index";
 import { Effect } from "effect";
-/**
- * Per-run monotonic execution-event sequence counter. Created inside
- * `AgentLoop.run` and closed over by the durable fold (delta / usage events) and
- * the `RelayToolExecutor` (tool events), so both share one counter exactly how
- * `state.nextEventSequence` threaded before Baton owned the loop.
- *
- * @experimental
- */
 export interface SequenceAllocator {
-    /** Return the current sequence and advance the counter by `count`. */
     readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
-    /** Read the current sequence without advancing. */
     readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
-    /**
-     * Set the counter to `sequence` (may move it down). Used to re-seed from the
-     * durable log after `ToolRuntime.run`, mirroring the old `nextLoggedSequence`
-     * recovery — a wait appends only `tool.call.requested`, so a naive advance
-     * would over-count.
-     */
     readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
 }
-/**
- * @experimental
- */
 export declare const make: (first: Execution.ExecutionEventSequence) => Effect.Effect<SequenceAllocator>;

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

@@ -1,7 +1,7 @@
 import { Agent, Execution, Ids, Shared } from "../../schema/index";
 import { ChildExecutionRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as EventLog from "../execution/event-log-service";
+import { Service as EventLogService } from "../execution/event-log-service";
 declare const StaticChildRunPresetNotFound_base: Schema.Class<StaticChildRunPresetNotFound, Schema.TaggedStruct<"StaticChildRunPresetNotFound", {
     readonly preset_name: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -80,7 +80,7 @@ export interface ResolvedChildContext {
     readonly outputSchemaRef?: string;
     readonly metadata: Shared.Metadata;
 }
-export declare const layer: Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLog.Service>;
+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>;

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

@@ -1,8 +1,8 @@
 import { Content, Ids } from "../../schema/index";
 import { ChildExecutionRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Ref, Schema } from "effect";
-import * as EventLog from "../execution/event-log-service";
-import * as WaitService from "../wait/wait-service";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { Service as WaitServiceService } from "../wait/wait-service";
 declare const ParentNotifyError_base: Schema.Class<ParentNotifyError, Schema.TaggedStruct<"ParentNotifyError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -32,8 +32,8 @@ export interface SignalParentWaitInput {
 export interface MakeOptions {
     readonly signalWait: (input: SignalParentWaitInput) => Effect.Effect<void, unknown>;
 }
-export declare const make: (options: MakeOptions) => Effect.Effect<Interface, never, ChildExecutionRepository.Service | EventLog.Service | WaitService.Service>;
-export declare const layerWith: (options: MakeOptions) => Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLog.Service | WaitService.Service>;
+export declare const make: (options: MakeOptions) => Effect.Effect<Interface, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;
+export declare const layerWith: (options: MakeOptions) => Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;
 export declare const memoryLayer: (notifications?: Ref.Ref<ReadonlyArray<NotifyInput>>) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const notify: (input: NotifyInput) => Effect.Effect<void, ParentNotifyError, Service>;

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

@@ -1,9 +1,9 @@
 import { Agent, Content, Execution, Ids, Shared } from "../../schema/index";
 import { Effect, Schema } from "effect";
-import * as EventLog from "../execution/event-log-service";
-import * as ToolRuntime from "../tool/tool-runtime-service";
-import * as WaitService from "../wait/wait-service";
-import * as ChildRunService from "./child-run-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";
+import type { Interface as ChildRunServiceInterface } from "./child-run-service";
 export declare const toolName = "spawn_child_run";
 export declare const permissionName = "relay.child_run.spawn";
 export declare const Input: Schema.Struct<{
@@ -189,23 +189,23 @@ export interface DispatchInput {
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly startedAt: number;
     readonly completedAt: number;
-    readonly agentDefinitionId: Ids.AgentDefinitionId;
-    readonly agentDefinitionRevision: Agent.DefinitionRevision;
-    readonly agentDefinitionSnapshot: Agent.Definition;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly agentId: Ids.AgentId;
+    readonly agentRevision: Agent.DefinitionRevision;
+    readonly agentSnapshot: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly metadata: Shared.Metadata;
 }
 export interface Config {
     readonly agent: Agent.Definition;
-    readonly agentDefinitionId: Ids.AgentDefinitionId;
-    readonly agentDefinitionRevision: Agent.DefinitionRevision;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
-    readonly childRuns: ChildRunService.Interface;
-    readonly eventLog: EventLog.Interface;
-    readonly waits: WaitService.Interface;
+    readonly agentId: Ids.AgentId;
+    readonly agentRevision: Agent.DefinitionRevision;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly childRuns: ChildRunServiceInterface;
+    readonly eventLog: EventLogInterface;
+    readonly waits: WaitServiceInterface;
     readonly dispatch: (input: DispatchInput) => Effect.Effect<void, unknown, any>;
 }
 export declare const enabled: (agent: Agent.Definition) => boolean;
-export declare const registeredTool: (config: Config) => ToolRuntime.RegisteredTool;
+export declare const registeredTool: (config: Config) => RegisteredTool;
 export declare const transferToolName: (name: string) => string;
-export declare const transferTools: (config: Config) => ReadonlyArray<ToolRuntime.RegisteredTool>;
+export declare const transferTools: (config: Config) => ReadonlyArray<RegisteredTool>;

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

@@ -4,9 +4,9 @@ import { Rpc } from "effect/unstable/rpc";
 import type { WorkflowEngine } from "effect/unstable/workflow";
 import { Schema } from "effect";
 import type { Effect } from "effect";
-import type * as EventLog from "../execution/event-log-service";
-import type * as WaitService from "../wait/wait-service";
-import * as ExecutionWorkflow from "../workflow/execution-workflow";
+import { ExecutionWorkflowFailed } from "../workflow/execution-workflow";
+import type { Service as EventLogService } from "../execution/event-log-service";
+import type { Service as WaitServiceService } from "../wait/wait-service";
 export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -69,11 +69,11 @@ export declare const Start: Rpc.Rpc<"start", 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<{
@@ -128,7 +128,7 @@ export declare const Start: Rpc.Rpc<"start", 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">;
     }>;
@@ -152,7 +152,7 @@ export declare const Start: Rpc.Rpc<"start", Schema.Struct<{
     }>;
     readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never>;
+}>, typeof ExecutionWorkflowFailed, never, never>;
 export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly workflow_execution_id: Schema.String;
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
@@ -160,7 +160,7 @@ export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
     };
     readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
     readonly signaled_at: Schema.Int;
-}>, Schema.Void, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never>;
+}>, Schema.Void, typeof ExecutionWorkflowFailed, never, never>;
 export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -172,7 +172,7 @@ export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never>;
+}>, typeof ExecutionWorkflowFailed, never, never>;
 export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -235,11 +235,11 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
     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<{
@@ -294,7 +294,7 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
         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">;
     }>;
@@ -318,14 +318,14 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
     }>;
     readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"signalWait", Schema.Struct<{
+}>, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly workflow_execution_id: Schema.String;
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     };
     readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
     readonly signaled_at: Schema.Int;
-}>, Schema.Void, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"cancel", Schema.Struct<{
+}>, Schema.Void, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"cancel", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
@@ -336,8 +336,8 @@ export declare const entity: Entity.Entity<"Relay/Execution", Rpc.Rpc<"start", S
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never>>;
-export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLog.Service | WaitService.Service | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
+}>, typeof ExecutionWorkflowFailed, never, never>>;
+export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLogService | WaitServiceService | WorkflowEngine.WorkflowEngine | import("effect/unstable/cluster/Sharding").Sharding>;
 export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<Rpc.Rpc<"start", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -400,11 +400,11 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
     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<{
@@ -459,7 +459,7 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
         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">;
     }>;
@@ -483,14 +483,14 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
     }>;
     readonly wait_state: Schema.optionalKey<Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"signalWait", Schema.Struct<{
+}>, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly workflow_execution_id: Schema.String;
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     };
     readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
     readonly signaled_at: Schema.Int;
-}>, Schema.Void, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"cancel", Schema.Struct<{
+}>, Schema.Void, typeof ExecutionWorkflowFailed, never, never> | Rpc.Rpc<"cancel", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
@@ -501,4 +501,4 @@ export declare const client: Effect.Effect<(entityId: string) => import("effect/
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     };
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-}>, typeof ExecutionWorkflow.ExecutionWorkflowFailed, never, never>, import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;
+}>, typeof ExecutionWorkflowFailed, never, never>, import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;

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

@@ -4,70 +4,23 @@ declare const ArtifactNotResolvable_base: Schema.Class<ArtifactNotResolvable, Sc
     readonly artifact_id: Schema.String;
     readonly reason: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/**
- * @experimental
- */
 export declare class ArtifactNotResolvable extends ArtifactNotResolvable_base {
 }
-/**
- * Artifacts resolve to Content parts (an artifact may be text, structured data,
- * or a blob reference). Resolution is single-level: the assembler resolves any
- * produced `blob-reference` through `BlobStore` in the same pass, but a nested
- * `artifact-reference` is an error.
- *
- * @experimental
- */
 export interface Interface {
     readonly resolve: (part: Content.ArtifactReferencePart) => Effect.Effect<ReadonlyArray<Content.Part>, ArtifactNotResolvable>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ArtifactStore", Interface>;
-/**
- * @experimental
- */
 export declare class Service extends Service_base {
 }
-/**
- * Default store: preserves today's behavior — every artifact reference resolves
- * to a single text part carrying the stringified reference.
- *
- * @experimental
- */
 export declare const passthroughLayer: Layer.Layer<Service>;
-/**
- * Memory store implementation plus a `register` helper for tests.
- *
- * @experimental
- */
 export interface MemoryInterface extends Interface {
     readonly register: (artifact_id: string, parts: ReadonlyArray<Content.Part>) => Effect.Effect<void>;
 }
 declare const Memory_base: Context.ServiceClass<Memory, "@relayfx/runtime/ArtifactStore/Memory", MemoryInterface>;
-/**
- * @experimental
- */
 export declare class Memory extends Memory_base {
 }
-/**
- * In-memory store; `resolve` fails typed when the artifact is unknown. Provides
- * both {@link Service} and {@link Memory} (for `register` in tests).
- *
- * @experimental
- */
 export declare const memoryLayer: Layer.Layer<Service | Memory>;
-/**
- * Wraps a custom store implementation as a layer.
- *
- * @experimental
- */
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
-/**
- * @experimental
- */
 export declare const resolve: (part: Content.ArtifactReferencePart) => Effect.Effect<readonly Content.Part[], ArtifactNotResolvable, Service>;
-/**
- * Registers artifact parts in the memory store (see {@link memoryLayer}).
- *
- * @experimental
- */
 export declare const register: (artifact_id: string, parts: readonly Content.Part[]) => Effect.Effect<void, never, Memory>;
 export {};

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

@@ -4,25 +4,13 @@ declare const BlobNotResolvable_base: Schema.Class<BlobNotResolvable, Schema.Tag
     readonly uri: Schema.String;
     readonly reason: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/**
- * @experimental
- */
 export declare class BlobNotResolvable extends BlobNotResolvable_base {
 }
 declare const BlobStoreError_base: Schema.Class<BlobStoreError, Schema.TaggedStruct<"BlobStoreError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/**
- * @experimental
- */
 export declare class BlobStoreError extends BlobStoreError_base {
 }
-/**
- * What a resolved blob looks like to the loop. `Url` means "pass this through to
- * the provider as-is"; `Bytes` means "hand these bytes to the provider".
- *
- * @experimental
- */
 export type ResolvedBlob = {
     readonly _tag: "Bytes";
     readonly bytes: Uint8Array;
@@ -34,41 +22,20 @@ export type ResolvedBlob = {
     readonly mediaType: string;
     readonly fileName?: string;
 };
-/**
- * @experimental
- */
 export interface PutBlobInput {
     readonly bytes: Uint8Array;
     readonly mediaType: string;
     readonly fileName?: string;
     readonly metadata?: Shared.Metadata;
 }
-/**
- * @experimental
- */
 export interface Interface {
     readonly resolve: (part: Content.BlobReferencePart) => Effect.Effect<ResolvedBlob, BlobNotResolvable | BlobStoreError>;
     readonly put: (input: PutBlobInput) => Effect.Effect<Content.BlobReferencePart, BlobStoreError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/BlobStore", Interface>;
-/**
- * @experimental
- */
 export declare class Service extends Service_base {
 }
-/**
- * Default store: preserves today's behavior bit-for-bit. `resolve` returns the
- * reference uri as a passthrough `Url`; `put` is unsupported.
- *
- * @experimental
- */
 export declare const passthroughLayer: Layer.Layer<Service>;
-/**
- * In-memory store. `put` mints monotonic `memory://blob/<n>` uris (no
- * `Math.random`); `resolve` fails typed when the uri is unknown.
- *
- * @experimental
- */
 export declare const memoryLayer: Layer.Layer<Service>;
 /**
  * Wraps a custom store implementation as a layer.

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

@@ -1,8 +1,8 @@
 import { Envelope, Execution, Ids } from "../../schema/index";
 import { EnvelopeRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as AddressBook from "../address/address-book-service";
-import * as EventLog from "../execution/event-log-service";
+import { Route, Service as AddressBookService } from "../address/address-book-service";
+import { Service as EventLogService } from "../execution/event-log-service";
 declare const EnvelopeAddressNotFound_base: Schema.Class<EnvelopeAddressNotFound, Schema.TaggedStruct<"EnvelopeAddressNotFound", {
     readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
@@ -45,8 +45,8 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EnvelopeService", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | AddressBook.Service | EventLog.Service>;
-export declare const memoryLayer: (routes?: Iterable<readonly [Ids.AddressId, AddressBook.Route]>) => Layer.Layer<Service, never, never>;
+export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | AddressBookService | EventLogService>;
+export declare const memoryLayer: (routes?: Iterable<readonly [Ids.AddressId, Route]>) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError, Service>;
 export {};

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

@@ -41,11 +41,6 @@ export interface Interface {
     readonly findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
     readonly findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
     readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, EventLogError>;
-    /**
-     * Total tokens (input + output) reported across every `model.usage.reported`
-     * event for the execution. Used to seed per-agent budget accounting on resume
-     * without replaying the full log.
-     */
     readonly sumUsage: (executionId: Ids.ExecutionId) => Effect.Effect<number, EventLogError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EventLog", Interface>;