@relayfx/sdk 0.0.39 → 0.0.40

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>;

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<{
@@ -190,22 +190,22 @@ export interface DispatchInput {
     readonly startedAt: number;
     readonly completedAt: number;
     readonly agentId: Ids.AgentId;
-    readonly agentDefinitionRevision: Agent.DefinitionRevision;
-    readonly agentDefinitionSnapshot: Agent.Definition;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly agentRevision: Agent.DefinitionRevision;
+    readonly agentSnapshot: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly metadata: Shared.Metadata;
 }
 export interface Config {
     readonly agent: Agent.Definition;
     readonly agentId: Ids.AgentId;
-    readonly agentDefinitionRevision: Agent.DefinitionRevision;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
-    readonly childRuns: ChildRunService.Interface;
-    readonly eventLog: EventLog.Interface;
-    readonly waits: WaitService.Interface;
+    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.AgentId"> & {
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
-    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+    readonly agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -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.AgentId"> & {
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
-    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+    readonly agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -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.AgentId"> & {
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
-    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+    readonly agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -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 {};