@relayfx/test 0.1.0

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

@@ -0,0 +1,65 @@
+import { Agent, Envelope, Execution, Ids, Shared } from "../../schema/index";
+import { ExecutionRepository } from "@relayfx/store-sql/portable";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
+import { ShardingConfig } from "effect/unstable/cluster";
+import { Service as ChildRunServiceService } from "../child/child-run-service";
+import { Service as EventLogService } from "./event-log-service";
+import type { ReplayInput } from "./event-log-service";
+declare const ExecutionServiceError_base: Schema.Class<ExecutionServiceError, Schema.TaggedStruct<"ExecutionServiceError", {
+    readonly message: Schema.String;
+    readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionServiceError extends ExecutionServiceError_base {
+}
+export interface AcceptInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly rootAddressId: Ids.AddressId;
+    readonly sessionId?: Ids.SessionId;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly createdAt: number;
+    readonly agentId?: Ids.AgentId;
+    readonly agentRevision?: Agent.DefinitionRevision;
+    readonly agentSnapshot?: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly metadata?: Shared.Metadata;
+}
+export interface RunInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly program: Effect.Effect<RunProgramResult, ExecutionServiceError>;
+}
+export interface RunProgramResult {
+    readonly _tag?: "completed" | "waiting";
+    readonly waitId?: Ids.WaitId;
+    readonly metadata?: Shared.Metadata;
+    readonly nextEventSequence?: Execution.ExecutionEventSequence;
+}
+export interface CancelInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly cancelledAt: number;
+    readonly reason?: string;
+}
+export interface Interface {
+    readonly accept: (input: AcceptInput) => Effect.Effect<Execution.Execution, ExecutionServiceError>;
+    readonly run: (input: RunInput) => Effect.Effect<Execution.Execution, ExecutionServiceError>;
+    readonly cancel: (input: CancelInput) => Effect.Effect<Execution.Execution, ExecutionServiceError>;
+    readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ExecutionServiceError>;
+    readonly spawnChildRun: (input: Execution.SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ExecutionServiceError>;
+    readonly stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, ExecutionServiceError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ExecutionService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, ExecutionRepository.Service | EventLogService | ChildRunServiceService | ShardingConfig.ShardingConfig>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const accept: (input: AcceptInput) => Effect.Effect<Execution.Execution, ExecutionServiceError, Service>;
+export declare const run: (input: RunInput) => Effect.Effect<Execution.Execution, ExecutionServiceError, Service>;
+export declare const cancel: (input: CancelInput) => Effect.Effect<Execution.Execution, ExecutionServiceError, Service>;
+export declare const send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ExecutionServiceError, Service>;
+export declare const spawnChildRun: (input: Execution.SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ExecutionServiceError, Service>;
+export declare const stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, ExecutionServiceError, Service>;
+export {};

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

@@ -0,0 +1,32 @@
+import { Execution, Ids } from "../../schema/index";
+import { ExecutionRepository } from "@relayfx/store-sql/portable";
+import { Context, Layer, Schema, Stream } from "effect";
+declare const ExecutionWatchError_base: Schema.Class<ExecutionWatchError, Schema.TaggedStruct<"ExecutionWatchError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionWatchError extends ExecutionWatchError_base {
+}
+export interface WatchInput {
+    readonly rootAddressId?: Ids.AddressId;
+    readonly sessionId?: Ids.SessionId;
+    readonly status?: Execution.ExecutionStatus;
+    readonly limit?: number;
+}
+export type ExecutionListChange = {
+    readonly _tag: "snapshot";
+    readonly records: ReadonlyArray<ExecutionRepository.ExecutionRecord>;
+    readonly nextCursor?: ExecutionRepository.ExecutionCursor;
+} | {
+    readonly _tag: "upsert";
+    readonly record: ExecutionRepository.ExecutionRecord;
+};
+export interface Interface {
+    readonly watch: (input: WatchInput) => Stream.Stream<ExecutionListChange, ExecutionWatchError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ExecutionWatch", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromServices: Layer.Layer<Service, never, ExecutionRepository.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, ExecutionRepository.Service>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

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

@@ -0,0 +1,33 @@
+import { Execution, Ids } from "../../schema/index";
+import { ExecutionRepository } from "@relayfx/store-sql/portable";
+import { Context, Layer, Schema, Stream } from "effect";
+import { EventLogCursorNotFound, Service as EventLogService } from "./event-log-service";
+declare const SessionStreamError_base: Schema.Class<SessionStreamError, Schema.TaggedStruct<"SessionStreamError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class SessionStreamError extends SessionStreamError_base {
+}
+export interface StreamInput {
+    readonly sessionId: Ids.SessionId;
+    readonly resume?: ReadonlyArray<{
+        readonly executionId: Ids.ExecutionId;
+        readonly afterCursor?: string;
+    }>;
+}
+export type SessionStreamItem = {
+    readonly _tag: "execution_joined";
+    readonly record: ExecutionRepository.ExecutionRecord;
+} | {
+    readonly _tag: "execution_event";
+    readonly event: Execution.ExecutionEvent;
+};
+export interface Interface {
+    readonly stream: (input: StreamInput) => Stream.Stream<SessionStreamItem, EventLogCursorNotFound | SessionStreamError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/SessionStream", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromServices: Layer.Layer<Service, never, ExecutionRepository.Service | EventLogService>;
+export declare const memoryLayer: Layer.Layer<Service, never, ExecutionRepository.Service | EventLogService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

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

@@ -0,0 +1,76 @@
+import { Content, Envelope, Execution, Ids, Inbox } from "../../schema/index";
+import { EnvelopeRepository, ExecutionRepository, InboxRepository } from "@relayfx/store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { Service as WaitService } from "../wait/wait-service";
+import type { ExecutionClientFactory } from "../wait/wait-signal";
+declare const InboxDeliveryError_base: Schema.Class<InboxDeliveryError, Schema.TaggedStruct<"InboxDeliveryError", {
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InboxDeliveryError extends InboxDeliveryError_base {
+}
+declare const InboxReplyTokenInvalid_base: Schema.Class<InboxReplyTokenInvalid, Schema.TaggedStruct<"InboxReplyTokenInvalid", {
+    readonly reply_token: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InboxReplyTokenInvalid extends InboxReplyTokenInvalid_base {
+}
+declare const InboxServiceError_base: Schema.Class<InboxServiceError, Schema.TaggedStruct<"InboxServiceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InboxServiceError extends InboxServiceError_base {
+}
+export interface DeliverInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly envelope: Envelope.Envelope;
+    readonly acceptance?: EnvelopeRepository.AcceptEnvelopeInput;
+    readonly idempotencyKey?: string;
+    readonly replyWaitId?: Ids.WaitId;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly createdAt: number;
+}
+export interface DeliverResult {
+    readonly sequence: Inbox.MessageSequence;
+    readonly deduplicated: boolean;
+}
+export interface DrainInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly drainId: string;
+    readonly maxBatch?: number;
+}
+export interface EnsureReplyWaitInput {
+    readonly envelope: Envelope.Envelope;
+    readonly waitId: Ids.WaitId;
+}
+export interface ReplyInput {
+    readonly replyToken: string;
+    readonly from: Ids.AddressId;
+    readonly content: ReadonlyArray<Content.Part>;
+    readonly createdAt: number;
+}
+export interface Interface {
+    readonly deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxDeliveryError>;
+    readonly ensureReplyWait: (input: EnsureReplyWaitInput) => Effect.Effect<void, InboxDeliveryError>;
+    readonly drain: (input: DrainInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, InboxServiceError>;
+    readonly undrainedCount: (executionId: Ids.ExecutionId) => Effect.Effect<number, InboxServiceError>;
+    readonly reply: (input: ReplyInput) => Effect.Effect<Envelope.EnvelopeAccepted, InboxReplyTokenInvalid | InboxDeliveryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/InboxService", Interface>;
+export declare class Service extends Service_base {
+}
+export interface SignalDependencies {
+    readonly makeExecutionClient: ExecutionClientFactory;
+    readonly executionRepository: ExecutionRepository.Service["Service"];
+}
+export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | InboxRepository.Service | EventLogService | WaitService>;
+export declare const layerWithSignal: (dependencies: SignalDependencies) => Layer.Layer<Service, never, EnvelopeRepository.Service | InboxRepository.Service | EventLogService | WaitService>;
+export declare const memoryLayer: Layer.Layer<Service, never, EventLogService | WaitService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxDeliveryError, Service>;
+export declare const ensureReplyWait: (input: EnsureReplyWaitInput) => Effect.Effect<void, InboxDeliveryError, Service>;
+export declare const drain: (input: DrainInput) => Effect.Effect<readonly Inbox.Message[], InboxServiceError, Service>;
+export declare const undrainedCount: (id: Ids.ExecutionId) => Effect.Effect<number, InboxServiceError, Service>;
+export declare const reply: (input: ReplyInput) => Effect.Effect<Envelope.EnvelopeAccepted, InboxDeliveryError | InboxReplyTokenInvalid, Service>;
+export {};

package/dist/types/runtime/inbox/send-message-tool.d.ts

@@ -0,0 +1,27 @@
+import { Ids } from "../../schema/index";
+import { Schema } from "effect";
+import type { Interface as EnvelopeInterface } from "../envelope/envelope-service";
+import type { RegisteredTool } from "../tool/tool-runtime-service";
+import type { Interface as InboxInterface } from "./inbox-service";
+export declare const toolName = "send_message";
+export declare const permissionName = "relay.inbox.send";
+export declare const Input: Schema.Struct<{
+    readonly to: Schema.String;
+    readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>]>;
+    readonly reply_token: Schema.optionalKey<Schema.String>;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly envelope_id: Schema.String;
+    readonly delivered: Schema.Literals<readonly ["inbox", "outbox", "reply"]>;
+}>;
+export interface Config {
+    readonly inbox: InboxInterface;
+    readonly envelopes: EnvelopeInterface;
+    readonly from: Ids.AddressId;
+}
+export declare const registeredTool: (config: Config) => RegisteredTool;

package/dist/types/runtime/inbox/wait-for-messages-tool.d.ts

@@ -0,0 +1,34 @@
+import { Schema } from "effect";
+import type { Interface as EventLogInterface } from "../execution/event-log-service";
+import type { Interface as WaitServiceInterface } from "../wait/wait-service";
+import type { RegisteredTool } from "../tool/tool-runtime-service";
+import type { Interface as InboxInterface } from "./inbox-service";
+export declare const toolName = "wait_for_messages";
+export declare const permissionName = "relay.inbox.wait";
+export declare const Input: Schema.Struct<{
+    readonly timeout: Schema.optionalKey<Schema.String>;
+}>;
+export interface Input extends Schema.Schema.Type<typeof Input> {
+}
+export declare const Output: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["messages", "timed_out"]>;
+    readonly messages: Schema.$Array<Schema.Struct<{
+        readonly sequence: Schema.Int;
+        readonly from: Schema.String;
+        readonly content: Schema.$Array<Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+            readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>>;
+        readonly reply_token: Schema.optionalKey<Schema.String>;
+        readonly correlation_key: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+}>;
+export interface Config {
+    readonly inbox: InboxInterface;
+    readonly waits: WaitServiceInterface;
+    readonly eventLog: EventLogInterface;
+}
+export declare const registeredTool: (config: Config) => RegisteredTool;

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

@@ -0,0 +1,51 @@
+export * as AddressBook from "./address/address-book-service";
+export * as AddressResolution from "./address/address-resolution-service";
+export * as AgentLoop from "./agent/agent-loop-service";
+export * as AgentRegistry from "./agent/agent-registry-service";
+export * as ArtifactStore from "./content/artifact-store-service";
+export * as BlobStore from "./content/blob-store-service";
+export * as ChildRunService from "./child/child-run-service";
+export * as SpawnChildRunTool from "./child/spawn-child-run-tool";
+export * as ExecutionEntity from "./cluster/execution-entity";
+export * as EnvelopeService from "./envelope/envelope-service";
+export * as EntityInstanceService from "./entity/entity-instance-service";
+export * as EntityRegistry from "./entity/entity-registry-service";
+export * as InboxService from "./inbox/inbox-service";
+export * as TopicService from "./topic/topic-service";
+export * as PublishToTopicTool from "./topic/publish-to-topic-tool";
+export * as SendMessageTool from "./inbox/send-message-tool";
+export * as WaitForMessagesTool from "./inbox/wait-for-messages-tool";
+export * as EventLog from "./execution/event-log-service";
+export * as ExecutionWatch from "./execution/execution-watch-service";
+export * as ExecutionService from "./execution/execution-service";
+export * as SessionStream from "./execution/session-stream-service";
+export * as EmbeddingModelService from "./model/embedding-model-service";
+export * as LanguageModelService from "./model/language-model-service";
+export * as MemoryService from "./memory/memory-service";
+export * as ModelCallPolicy from "./model/model-call-policy";
+export * as ParentNotifier from "./child/parent-notifier-service";
+export * as PresenceService from "./presence/presence-service";
+export * as PresenceTool from "./presence/presence-tool";
+export * as PromptAssembler from "./agent/prompt-assembler-service";
+export * as RelayCompaction from "./agent/relay-compaction";
+export * as RelayPermissions from "./agent/relay-permissions";
+export * as RelaySteering from "./agent/relay-steering";
+export * as RelayToolOutput from "./agent/relay-tool-output";
+export * as RunnerRuntime from "./runner/runner-runtime-service";
+export * as SchedulerService from "./schedule/scheduler-service";
+export * as SchemaRegistry from "./schema-registry/schema-registry-service";
+export * as RelaySessionStore from "./session/session-store-service";
+export * as SkillRegistry from "./skill/skill-registry-service";
+export * as ExecutionState from "./state/execution-state-service";
+export * as StateTools from "./state/state-tools";
+export * as ToolRuntime from "./tool/tool-runtime-service";
+export * as ToolTransitionCoordinator from "./tool/tool-transition-coordinator";
+export * as ToolInputSchemaDigest from "./tool/tool-input-schema-digest";
+export * as WaitService from "./wait/wait-service";
+export * as WaitSignal from "./wait/wait-signal";
+export * as WorkspacePlanner from "./workspace/workspace-planner-service";
+export * as WorkspaceProvider from "./workspace/workspace-provider-service";
+export * as WorkspaceRuntime from "./workspace/workspace-runtime-service";
+export * as ExecutionWorkflow from "./workflow/execution-workflow";
+export * as ActivityVersionRegistry from "./workflow/activity-version-registry";
+export declare const runtimePackage = "./index";

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

@@ -0,0 +1,22 @@
+import { Memory } from "@batonfx/core";
+import { MemoryRepository } from "@relayfx/store-sql/portable";
+import { Context, Effect, Layer } from "effect";
+import { Service as EmbeddingModelServiceService } from "../model/embedding-model-service";
+import type { ModelSelection } from "../model/embedding-model-service";
+export interface Options {
+    readonly topK?: number | undefined;
+    readonly minScore?: number | undefined;
+    readonly embeddingSelection?: ModelSelection | undefined;
+}
+export interface Interface extends Memory.Interface {
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/MemoryService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (options?: Options) => Layer.Layer<Service | Memory.Memory, never, MemoryRepository.Service | EmbeddingModelServiceService>;
+export declare const memoryLayer: (options?: Options) => Layer.Layer<Service | Memory.Memory, never, MemoryRepository.Service | EmbeddingModelServiceService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service | Memory.Memory>;
+export declare const recall: (input: Memory.RecallInput) => Effect.Effect<readonly Memory.Item[], Memory.MemoryError, Service>;
+export declare const remember: (input: Memory.RememberInput) => Effect.Effect<void, Memory.MemoryError, Service>;
+export declare const forget: (input: Memory.ForgetInput) => Effect.Effect<void, Memory.MemoryError, Service>;
+export {};

package/dist/types/runtime/model/embedding-model-service.d.ts

@@ -0,0 +1,68 @@
+import { Agent, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { EmbeddingModel, Model } from "effect/unstable/ai";
+declare const EmbeddingModelNotRegistered_base: Schema.Class<EmbeddingModelNotRegistered, Schema.TaggedStruct<"EmbeddingModelNotRegistered", {
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    readonly registration_key: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class EmbeddingModelNotRegistered extends EmbeddingModelNotRegistered_base {
+}
+export interface ModelSelection {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+}
+export type ModelEnvironment = EmbeddingModel.EmbeddingModel | EmbeddingModel.Dimensions | Model.ProviderName | Model.ModelName;
+export interface Registration {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+    readonly layer: Layer.Layer<ModelEnvironment>;
+    readonly metadata?: Shared.Metadata | undefined;
+}
+export interface RegisterInput {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+    readonly layer: Layer.Layer<ModelEnvironment>;
+    readonly metadata?: Shared.Metadata | undefined;
+}
+export interface LayerOptions {
+    readonly defaultSelection?: ModelSelection | undefined;
+}
+export interface DeterministicOptions {
+    readonly provider?: string | undefined;
+    readonly model?: string | undefined;
+    readonly dimensions?: number | undefined;
+}
+export interface Interface {
+    readonly register: (input: RegisterInput) => Effect.Effect<void>;
+    readonly registrations: Effect.Effect<ReadonlyArray<Registration>>;
+    readonly provide: <A, E, R>(selection: ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Exclude<R, ModelEnvironment>>;
+    readonly provideDefault: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Exclude<R, ModelEnvironment>>;
+    readonly provideForAgent: <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Exclude<R, ModelEnvironment>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EmbeddingModelService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const registrationFromLayer: <Provides extends ModelEnvironment, R>(input: {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string | undefined;
+    readonly layer: Layer.Layer<Provides, never, R>;
+    readonly metadata?: Shared.Metadata | undefined;
+}) => Effect.Effect<Registration, never, R>;
+export declare const layer: (initialRegistrations?: ReadonlyArray<Registration>, options?: LayerOptions) => Layer.Layer<Service, never, never>;
+export declare const layerFromRegistrationEffects: <E, R>(registrations: ReadonlyArray<Effect.Effect<Registration, E, R>>, options?: LayerOptions) => Layer.Layer<Service, E, Exclude<R, import("effect/Scope").Scope>>;
+export declare const memoryLayer: (initialRegistrations?: ReadonlyArray<Registration>, options?: LayerOptions) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const deterministicLayer: (options?: DeterministicOptions) => Layer.Layer<EmbeddingModel.EmbeddingModel | EmbeddingModel.Dimensions, never, never>;
+export declare const deterministicRegistration: (options?: DeterministicOptions) => Effect.Effect<Registration, never, never>;
+export declare const deterministicTestLayer: (options?: DeterministicOptions) => Layer.Layer<Service, never, never>;
+export declare const register: (input: RegisterInput) => Effect.Effect<void, never, Service>;
+export declare const registrations: () => Effect.Effect<readonly Registration[], never, Service>;
+export declare const provide: <A, E, R>(selection: ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, EmbeddingModelNotRegistered | E, Service | Exclude<R, ModelEnvironment>>;
+export declare const provideDefault: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, EmbeddingModelNotRegistered | E, Service | Exclude<R, ModelEnvironment>>;
+export declare const provideForAgent: <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, EmbeddingModelNotRegistered | E, Service | Exclude<R, ModelEnvironment>>;
+export {};

package/dist/types/runtime/model/language-model-service.d.ts

@@ -0,0 +1,34 @@
+import { ModelRegistry } from "@batonfx/core";
+import { Agent } from "../../schema/index";
+import { Context, Effect, Layer } from "effect";
+export declare const LanguageModelNotRegistered: typeof ModelRegistry.LanguageModelNotRegistered;
+export type LanguageModelNotRegistered = ModelRegistry.LanguageModelNotRegistered;
+export type Registration = ModelRegistry.Registration;
+export type GovernanceOptions = ModelRegistry.GovernanceOptions;
+export type RegisterInput = ModelRegistry.RegisterInput;
+export type ModelEnvironment = ModelRegistry.ModelEnvironment;
+export interface Interface {
+    readonly register: (input: RegisterInput) => Effect.Effect<void>;
+    readonly registrations: Effect.Effect<ReadonlyArray<Registration>>;
+    readonly provide: <A, E, R>(selection: Agent.ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | LanguageModelNotRegistered, Exclude<R, ModelEnvironment>>;
+    readonly provideForAgent: <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | LanguageModelNotRegistered, Exclude<R, ModelEnvironment>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/LanguageModelService", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const registrationFromLayer: <R>(input: {
+    readonly provider: string;
+    readonly model: string;
+    readonly registrationKey?: string;
+    readonly layer: Layer.Layer<import("effect/unstable/ai/LanguageModel").LanguageModel, never, R>;
+    readonly metadata?: ModelRegistry.Metadata;
+}) => Effect.Effect<ModelRegistry.Registration, never, R>;
+export declare const layer: (initialRegistrations?: ReadonlyArray<Registration>, options?: GovernanceOptions) => Layer.Layer<Service, never, never>;
+export declare const layerFromRegistrationEffects: <E, R>(registrations: ReadonlyArray<Effect.Effect<Registration, E, R>>, options?: GovernanceOptions) => Layer.Layer<Service, E, Exclude<R, import("effect/Scope").Scope>>;
+export declare const memoryLayer: (initialRegistrations?: ReadonlyArray<Registration>, options?: GovernanceOptions) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const register: (input: ModelRegistry.RegisterInput) => Effect.Effect<void, never, Service>;
+export declare const registrations: () => Effect.Effect<readonly ModelRegistry.Registration[], never, Service>;
+export declare const provide: <A, E, R>(selection: Agent.ModelSelection, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, ModelRegistry.LanguageModelNotRegistered | E, Service | Exclude<R, ModelRegistry.ModelEnvironment>>;
+export declare const provideForAgent: <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, ModelRegistry.LanguageModelNotRegistered | E, Service | Exclude<R, ModelRegistry.ModelEnvironment>>;
+export {};

package/dist/types/runtime/model/model-call-policy.d.ts

@@ -0,0 +1,14 @@
+import { ModelResilience } from "@batonfx/core";
+import { Context, Layer, Schedule } from "effect";
+export type Classification = ModelResilience.Classification;
+export type Interface = ModelResilience.Interface;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ModelCallPolicy", ModelResilience.Interface>;
+export declare class Service extends Service_base {
+}
+export declare const defaultClassify: (error: unknown) => Classification;
+export declare const defaultSchedule: Schedule.Schedule<unknown>;
+export declare const make: (input?: Partial<Interface>) => Interface;
+export declare const layer: (input?: Partial<Interface>) => Layer.Layer<Service, never, never>;
+export declare const noRetryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

package/dist/types/runtime/observability/runtime-metrics.d.ts

@@ -0,0 +1,19 @@
+import { Effect } from "effect";
+export declare const recordExecutionAccepted: Effect.Effect<void, never, never>;
+export declare const recordExecutionFinished: (status: string) => Effect.Effect<void, never, never>;
+export declare const recordEnvelopeSent: (routeKind: string) => Effect.Effect<void, never, never>;
+export declare const recordWaitTransitioned: (state: string) => Effect.Effect<void, never, never>;
+export declare const recordChildRunSpawned: (kind: string) => Effect.Effect<void, never, never>;
+export declare const recordAddressResolved: (routeKind: string) => Effect.Effect<void, never, never>;
+export declare const recordEventAppended: (eventType: string) => Effect.Effect<void, never, never>;
+export declare const recordEventReplayed: (source: string, count: number) => Effect.Effect<void, never, never>;
+export declare const recordRunnerReadinessChecked: (database: string) => Effect.Effect<void, never, never>;
+export declare const recordModelUsage: (input: {
+    readonly provider: string;
+    readonly model: string;
+    readonly finishReason: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}) => Effect.Effect<void, never, never>;
+export declare const recordToolCall: (tool: string, outcome: "success" | "failure" | "denied" | "wait") => Effect.Effect<void, never, never>;
+export declare const recordExecutionDuration: (status: string, durationMillis: number) => Effect.Effect<void, never, never>;

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

@@ -0,0 +1,30 @@
+import { Presence, Shared } from "../../schema/index";
+import { PresenceRepository } from "@relayfx/store-sql/portable";
+import { Config, Context, Effect, Layer, Schema, Scope, Stream } from "effect";
+declare const PresenceError_base: Schema.Class<PresenceError, Schema.TaggedStruct<"PresenceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PresenceError extends PresenceError_base {
+}
+export interface RegisterInput {
+    readonly id: string;
+    readonly scope: Presence.Scope;
+    readonly metadata?: Shared.Metadata;
+}
+export interface Interface {
+    readonly register: (input: RegisterInput) => Effect.Effect<void, never, Scope.Scope>;
+    readonly tracked: (scope: Presence.Scope, metadata?: Shared.Metadata) => <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>;
+    readonly list: (scope: Presence.Scope) => Effect.Effect<Presence.View, PresenceError>;
+    readonly watch: (scope: Presence.Scope) => Stream.Stream<Presence.View, PresenceError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/Presence", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const PresenceIdentity: Context.Reference<Shared.Metadata>;
+export declare const layerFromRepository: Layer.Layer<Service, Config.ConfigError, PresenceRepository.Service>;
+export declare const memoryLayer: Layer.Layer<Service, Config.ConfigError, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const register: (input: RegisterInput) => Effect.Effect<void, never, Scope.Scope | Service>;
+export declare const list: (scope: Presence.Scope) => Effect.Effect<Presence.View, PresenceError, Service>;
+export declare const watch: (scope: Presence.Scope) => Stream.Stream<Presence.View, PresenceError, Service>;
+export {};

package/dist/types/runtime/presence/presence-tool.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from "effect";
+import type { Interface as PresenceInterface } from "./presence-service";
+import type { RegisteredTool } from "../tool/tool-runtime-service";
+export declare const toolName = "relay_presence";
+export declare const permissionName = "relay.presence.read";
+export declare const Input: Schema.Struct<{
+    readonly scope: Schema.optionalKey<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["execution", "session"]>;
+        readonly id: Schema.String;
+    }>>;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly watcher_count: Schema.Number;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly connected_at: Schema.Int;
+    }>>;
+}>;
+export declare const registeredTool: (presence: PresenceInterface) => RegisteredTool;