@relayfx/test 0.3.1 → 0.3.2

package/dist/types/test/index.d.ts

@@ -1,5 +1,3 @@
-export * as ScriptedModel from "./scripted-model";
-export * as CapturedModel from "./captured-model";
 export * as TestTools from "./test-tools";
 export * as TestRuntime from "./test-runtime";
 export * as WaitTestKit from "./wait-test-kit";

package/dist/types/test/test-runtime.d.ts

@@ -1,9 +1,8 @@
-import { RunnerRuntime, ToolRuntime } from "../runtime/index";
+import type { TestModel } from "@batonfx/test";
+import { Runtime, ToolRuntime } from "@relayfx/sdk";
 import { Layer } from "effect";
-import { LanguageModel } from "effect/unstable/ai";
-import type { ScriptedTurn } from "./scripted-model";
-export declare const layer: typeof RunnerRuntime.testLayer;
+export declare const layer: Layer.Layer<Runtime.EmbeddedOutput, Runtime.AcquisitionError, never>;
 export declare const layerWith: (options: {
-    readonly model?: Layer.Layer<LanguageModel.LanguageModel> | ReadonlyArray<ScriptedTurn>;
-    readonly tools?: ReadonlyArray<ToolRuntime.RegisteredTool>;
-}) => typeof RunnerRuntime.testLayer;
+    readonly model?: TestModel.Fixture;
+    readonly tools?: NonNullable<Parameters<typeof ToolRuntime.layer>[0]>;
+}) => Layer.Layer<Runtime.EmbeddedOutput, Runtime.AcquisitionError, never>;

package/dist/types/test/test-tools.d.ts

@@ -1,5 +1,5 @@
-import { ToolRuntime } from "../runtime/index";
-import type { Ids, Shared, Tool } from "../schema/index";
+import { ToolRuntime } from "@relayfx/sdk";
+import type { Ids, Shared, Tool } from "@relayfx/sdk";
 import { Effect } from "effect";
 export interface CapturedTool {
     readonly registered: ToolRuntime.RegisteredTool;

package/dist/types/test/wait-test-kit.d.ts

@@ -1,4 +1,4 @@
-import type { Ids } from "../schema/index";
+import type { Ids } from "@relayfx/sdk";
 import { Client, Operation } from "@relayfx/sdk";
 import { Effect } from "effect";
 export declare const runThroughWait: <E, R>(options: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/test",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Experimental deterministic test kit for Relay applications",
   "type": "module",
   "exports": {
@@ -30,16 +30,17 @@
     "url": "https://github.com/In-Time-Tec/relayfx/issues"
   },
   "scripts": {
-    "build": "rm -rf dist && bun build ./src/index.ts --outdir dist --target bun --format esm --external effect --external 'effect/*' --external '@effect/*' --external '@relayfx/sdk' --external '@relayfx/sdk/*' && bun ../relay/scripts/build-types.ts && bun scripts/build-types.ts",
+    "build": "rm -rf dist && bun build ./src/index.ts --outdir dist --target bun --format esm --external effect --external 'effect/*' --external '@effect/*' --external '@relayfx/sdk' --external '@relayfx/sdk/*' && bun scripts/build-types.ts",
     "lint": "bun --cwd ../.. oxlint packages/test/src packages/test/scripts packages/test/test",
-    "test": "bun --cwd ../.. vitest run packages/test/test --passWithNoTests",
+    "test": "bun --cwd ../.. --bun vitest run packages/test/test --passWithNoTests",
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@relayfx/sdk": "0.3.1",
-    "effect": "4.0.0-beta.93"
+    "@batonfx/test": "0.6.0",
+    "@relayfx/sdk": "0.3.2",
+    "effect": "4.0.0-beta.98"
   },
   "peerDependencies": {
-    "@effect/vitest": "4.0.0-beta.93"
+    "@effect/vitest": "4.0.0-beta.98"
   }
 }

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

@@ -1,74 +0,0 @@
-import { Address, Ids } from "../../schema/index";
-import { AddressBookRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-export declare const RouteKind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-export type RouteKind = typeof RouteKind.Type;
-export declare const Route: Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-    readonly route_key: Schema.String;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>;
-export interface Route extends Address.Route {
-}
-export declare const RouteRecord: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
-    };
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly route: Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-        readonly route_key: Schema.String;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>;
-    readonly created_at: Schema.Int;
-    readonly updated_at: Schema.Int;
-}>;
-export interface RouteRecord extends Address.RouteRecord {
-}
-declare const AddressNotFound_base: Schema.Class<AddressNotFound, Schema.TaggedStruct<"AddressNotFound", {
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressNotFound extends AddressNotFound_base {
-}
-declare const AddressUnavailable_base: Schema.Class<AddressUnavailable, Schema.TaggedStruct<"AddressUnavailable", {
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly route_key: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressUnavailable extends AddressUnavailable_base {
-}
-declare const AddressDeferred_base: Schema.Class<AddressDeferred, Schema.TaggedStruct<"AddressDeferred", {
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly route_key: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressDeferred extends AddressDeferred_base {
-}
-declare const AddressBookServiceError_base: Schema.Class<AddressBookServiceError, Schema.TaggedStruct<"AddressBookServiceError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressBookServiceError extends AddressBookServiceError_base {
-}
-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>;
-}
-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, 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>;
-export {};

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

@@ -1,172 +0,0 @@
-import { Agent, Ids } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as AddressBookService } from "./address-book-service";
-import { Service as AgentRegistryService } from "../agent/agent-registry-service";
-declare const AddressRouteNotFound_base: Schema.Class<AddressRouteNotFound, Schema.TaggedStruct<"AddressRouteNotFound", {
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressRouteNotFound extends AddressRouteNotFound_base {
-}
-declare const AddressRouteKindMismatch_base: Schema.Class<AddressRouteKindMismatch, Schema.TaggedStruct<"AddressRouteKindMismatch", {
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly expected: Schema.Literal<"local-agent">;
-    readonly actual: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
-    readonly route_key: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressRouteKindMismatch extends AddressRouteKindMismatch_base {
-}
-declare const AddressAgentDefinitionNotFound_base: Schema.Class<AddressAgentDefinitionNotFound, Schema.TaggedStruct<"AddressAgentDefinitionNotFound", {
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressAgentDefinitionNotFound extends AddressAgentDefinitionNotFound_base {
-}
-declare const AddressResolutionError_base: Schema.Class<AddressResolutionError, Schema.TaggedStruct<"AddressResolutionError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class AddressResolutionError extends AddressResolutionError_base {
-}
-export declare const LocalAgentRoute: Schema.Struct<{
-    readonly kind: Schema.Literal<"local-agent">;
-    readonly route_key: Schema.String;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-}>;
-export interface LocalAgentRoute extends Schema.Schema.Type<typeof LocalAgentRoute> {
-}
-export declare const LocalAgentTarget: Schema.Struct<{
-    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
-    };
-    readonly route: Schema.Struct<{
-        readonly kind: Schema.Literal<"local-agent">;
-        readonly route_key: Schema.String;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>;
-    readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
-    };
-    readonly agent_revision: Schema.Int;
-    readonly agent_snapshot: Schema.Codec<Agent.Definition, {
-        readonly name: string;
-        readonly instructions?: string;
-        readonly 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 tool_names: readonly 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" | "ask" | "deny";
-                readonly reason?: string;
-            }[];
-            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 instructions?: string;
-                readonly 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 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 tool_names?: readonly string[];
-                readonly permissions?: readonly string[];
-                readonly workspace_policy?: {
-                    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>>;
-}>;
-export interface LocalAgentTarget extends Schema.Schema.Type<typeof LocalAgentTarget> {
-}
-export interface Interface {
-    readonly resolveLocalAgent: (addressId: Ids.AddressId) => Effect.Effect<LocalAgentTarget, AddressRouteNotFound | AddressRouteKindMismatch | AddressAgentDefinitionNotFound | AddressResolutionError>;
-}
-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, AddressAgentDefinitionNotFound | AddressResolutionError | AddressRouteKindMismatch | AddressRouteNotFound, Service>;
-export {};

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

@@ -1,92 +0,0 @@
-import { Agent, Content, Execution, Ids, Shared, Tool } from "../../schema/index";
-import { AgentChatRepository } from "@relayfx/store-sql/portable";
-import { Cause, Context, Effect, Layer, Schema } from "effect";
-import { Tool as AiTool } from "effect/unstable/ai";
-import type { DispatchInput } from "../child/spawn-child-run-tool";
-import { Service as EventLogService } from "../execution/event-log-service";
-import { Service as LanguageModelServiceService } from "../model/language-model-service";
-import { Service as ModelCallPolicyService } from "../model/model-call-policy";
-import { Service as SchemaRegistryService } from "../schema-registry/schema-registry-service";
-import { Service as ToolRuntimeService } from "../tool/tool-runtime-service";
-import 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;
-    readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
-}>, Cause.YieldableError>;
-export declare class AgentLoopError extends AgentLoopError_base {
-}
-declare const AgentLoopWaitRequested_base: Schema.Class<AgentLoopWaitRequested, Schema.TaggedStruct<"AgentLoopWaitRequested", {
-    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 tool_call: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-        };
-        readonly name: Schema.String;
-        readonly input: 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 next_event_sequence: Schema.Int;
-}>, Cause.YieldableError>;
-export declare class AgentLoopWaitRequested extends AgentLoopWaitRequested_base {
-}
-declare const AgentLoopBudgetExceeded_base: Schema.Class<AgentLoopBudgetExceeded, Schema.TaggedStruct<"AgentLoopBudgetExceeded", {
-    readonly tokens_used: Schema.Int;
-    readonly token_budget: Schema.Int;
-    readonly next_event_sequence: Schema.Int;
-}>, Cause.YieldableError>;
-export declare class AgentLoopBudgetExceeded extends AgentLoopBudgetExceeded_base {
-}
-export interface RunInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly sessionId?: Ids.SessionId;
-    readonly agent: Agent.Definition;
-    readonly agentId?: Ids.AgentId;
-    readonly agentRevision?: Agent.DefinitionRevision;
-    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
-    readonly input: ReadonlyArray<Content.Part>;
-    readonly resumeToolCall?: Tool.Call;
-    readonly memorySubjectId?: Ids.MemorySubjectId;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly startedAt: number;
-    readonly completedAt: number;
-    readonly steeringEnabled?: boolean;
-    readonly toolOutputMaxBytes?: number | null;
-    readonly sessionEntryScope?: string;
-    readonly dispatchChildRun?: (input: DispatchInput) => Effect.Effect<void, ToolRuntimeError>;
-}
-export interface RunResult {
-    readonly metadata: Shared.Metadata;
-    readonly nextEventSequence: Execution.ExecutionEventSequence;
-}
-export interface Interface {
-    readonly run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/agent/agent-loop-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-/**
- * Prompt for the terminal structured turn. The transcript already holds the full
- * conversation history (system message, user input, and every tool result), so
- * this single instruction is enough to elicit the typed final output.
- *
- * @experimental
- */
-export declare const STRUCTURED_TURN_PROMPT = "Return the final structured output for the task above.";
-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: {
-    (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, AgentLoopBudgetExceeded | AgentLoopError | AgentLoopWaitRequested, Service>;
-export {};

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

@@ -1,31 +0,0 @@
-import { Agent, Ids } from "../../schema/index";
-import { AgentDefinitionRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-declare const AgentDefinitionInvalid_base: Schema.Class<AgentDefinitionInvalid, Schema.TaggedStruct<"AgentDefinitionInvalid", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class AgentDefinitionInvalid extends AgentDefinitionInvalid_base {
-}
-declare const AgentRegistryError_base: Schema.Class<AgentRegistryError, Schema.TaggedStruct<"AgentRegistryError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class AgentRegistryError extends AgentRegistryError_base {
-}
-export interface Interface {
-    readonly register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError>;
-    readonly get: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError>;
-    readonly getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError>;
-    readonly list: Effect.Effect<Agent.DefinitionList, AgentRegistryError>;
-    readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError>;
-}
-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>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError, Service>;
-export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError, Service>;
-export declare const getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError, Service>;
-export declare const list: () => Effect.Effect<Agent.DefinitionList, AgentRegistryError, Service>;
-export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError, Service>;
-export {};

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

@@ -1,64 +0,0 @@
-import { Agent, Content, Shared, Tool } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
-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>;
-export declare class PromptAssemblerError extends PromptAssemblerError_base {
-}
-export interface AssembleInput {
-    readonly agent: Agent.Definition;
-    readonly tools: ReadonlyArray<Tool.Definition>;
-    readonly input: ReadonlyArray<Content.Part>;
-    readonly tokenBudget?: number;
-    readonly metadata?: Shared.Metadata;
-}
-export interface Assembled {
-    readonly system: string;
-    readonly prompt: Prompt.Prompt;
-}
-export interface Interface {
-    readonly assemble: (input: AssembleInput) => Effect.Effect<Assembled, PromptAssemblerError>;
-}
-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;
-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
- * both stores to be provided (`runner-runtime-service.ts` wires passthrough
- * stores by default; see `docs/spec/29-blob-and-artifact-stores.md`).
- *
- * @experimental
- */
-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`).
- * Bakes in passthrough stores so it stays self-contained and behavior is
- * preserved bit-for-bit (see `docs/spec/29-blob-and-artifact-stores.md`).
- *
- * @experimental
- */
-export declare const defaultLayer: Layer.Layer<Service>;
-/**
- * Wraps a custom assembler implementation as a layer.
- *
- * @experimental
- */
-export declare const layer: (implementation: Interface) => Layer.Layer<Service>;
-/**
- * Alias of {@link layer} for test wiring.
- *
- * @experimental
- */
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
-/**
- * @experimental
- */
-export declare const assemble: (input: AssembleInput) => Effect.Effect<Assembled, PromptAssemblerError, Service>;
-export {};

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

@@ -1,2 +0,0 @@
-import { Approvals } from "@batonfx/core";
-export declare const layer: import("effect/Layer").Layer<Approvals.Approvals, never, never>;

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

@@ -1,24 +0,0 @@
-import { Compaction, ModelRegistry } from "@batonfx/core";
-import { Ids } from "../../schema/index";
-import { CompactionRepository } from "@relayfx/store-sql/portable";
-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;
-    readonly repository: CompactionRepository.Interface;
-    readonly options?: Options;
-    readonly strategy?: Compaction.Strategy;
-}
-export declare const checkpointId: (input: {
-    readonly executionId: Ids.ExecutionId;
-    readonly turn: number;
-    readonly firstKeptEntryId: Ids.SessionEntryId | string;
-}) => string;
-export declare const strategy: (config: Config) => Compaction.Strategy;
-export declare const make: (config: Config) => Compaction.Interface;
-export declare const layer: (config: Config) => Layer.Layer<Compaction.Compaction>;

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

@@ -1,7 +0,0 @@
-import { Instructions } from "@batonfx/core";
-export interface ContextEpoch {
-    readonly baseline: string;
-    readonly dynamicSourceIds: ReadonlyArray<string>;
-}
-export declare const layerFromEpoch: (epoch: ContextEpoch) => import("effect/Layer").Layer<Instructions.Instructions, never, never>;
-export declare const layer: (system: string) => import("effect/Layer").Layer<Instructions.Instructions, never, never>;

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

@@ -1,25 +0,0 @@
-import { Permissions } from "@batonfx/core";
-import { Agent, Execution, Ids } from "../../schema/index";
-import { PermissionRuleRepository } from "@relayfx/store-sql/portable";
-import { Effect, Layer } from "effect";
-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>;
-    readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
-}
-export interface Config {
-    readonly ruleset: Agent.PermissionRuleset;
-    readonly repository: PermissionRuleRepository.Interface;
-    readonly waits: WaitServiceInterface;
-    readonly eventLog: EventLogInterface;
-    readonly allocator: SequenceAllocator;
-    readonly executionId: Ids.ExecutionId;
-    readonly agentName: string;
-    readonly scope: string;
-    readonly startedAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-}
-export declare const waitIdForToolCall: (toolCallId: string) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-export declare const layer: (config: Config) => Layer.Layer<Permissions.Permissions | Permissions.RuleStore, never, never>;

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

@@ -1,17 +0,0 @@
-import { Steering } from "@batonfx/core";
-import { Execution, Ids } from "../../schema/index";
-import { SteeringRepository } from "@relayfx/store-sql/portable";
-import { Effect, Layer } from "effect";
-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: Interface;
-    readonly allocator: SequenceAllocator;
-    readonly executionId: Ids.ExecutionId;
-    readonly startedAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-}
-export declare const layer: (config: Config) => Layer.Layer<Steering.Steering>;

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

@@ -1,22 +0,0 @@
-import { ToolExecutor } from "@batonfx/core";
-import { Execution, Ids, Tool } from "../../schema/index";
-import { Effect, Layer } from "effect";
-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: ToolRuntimeInterface;
-    readonly eventLog: EventLogInterface;
-    readonly allocator: {
-        readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
-        readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
-    };
-    readonly executionId: Ids.ExecutionId;
-    readonly permissions: ReadonlyArray<Tool.Permission>;
-    readonly startedAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly toolOutputMaxBytes?: number;
-    readonly resumedToolCallId?: Ids.ToolCallId;
-    readonly extraTools?: ReadonlyArray<RegisteredTool>;
-}
-export declare const make: (config: Config) => ToolExecutor.Interface;
-export declare const layer: (config: Config) => Layer.Layer<ToolExecutor.ToolExecutor>;

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

@@ -1,10 +0,0 @@
-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>;
-    (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/agent/sequence-allocator.d.ts

@@ -1,8 +0,0 @@
-import { Execution } from "../../schema/index";
-import { Effect } from "effect";
-export interface SequenceAllocator {
-    readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
-    readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
-    readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
-}
-export declare const make: (first: Execution.ExecutionEventSequence) => Effect.Effect<SequenceAllocator>;