@relayfx/test 0.2.15 → 0.3.0

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

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

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

@@ -43,26 +43,39 @@ export interface Interface {
     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>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/model/embedding-model-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const registrationFromLayer: <Provides extends ModelEnvironment, R>(input: {
+export declare const registrationFromLayer: <R>(input: {
     readonly provider: string;
     readonly model: string;
     readonly registrationKey?: string | undefined;
-    readonly layer: Layer.Layer<Provides, never, R>;
+    readonly layer: Layer.Layer<EmbeddingModel.EmbeddingModel | EmbeddingModel.Dimensions, 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 layer: {
+    (): Layer.Layer<Service>;
+    (options?: LayerOptions): (initialRegistrations?: ReadonlyArray<Registration>) => Layer.Layer<Service>;
+    (initialRegistrations?: ReadonlyArray<Registration>, options?: LayerOptions): Layer.Layer<Service>;
+};
+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>>;
+    (options?: LayerOptions): <E, R>(registrations: ReadonlyArray<Effect.Effect<Registration, E, R>>) => Layer.Layer<Service, E, Exclude<R, import("effect/Scope").Scope>>;
+};
+export declare const memoryLayer: typeof layer;
 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 deterministicLayer: (options?: DeterministicOptions) => Layer.Layer<EmbeddingModel.Dimensions | EmbeddingModel.EmbeddingModel, 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 declare const provide: {
+    <A, E, R>(selection: ModelSelection, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | EmbeddingModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+    (selection: ModelSelection): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+};
+export declare const provideDefault: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+export declare const provideForAgent: {
+    <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | EmbeddingModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+    (agent: Agent.Definition): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | EmbeddingModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+};
 export {};

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

@@ -13,7 +13,7 @@ export interface Interface {
     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>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/model/language-model-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const registrationFromLayer: <R>(input: {
@@ -23,13 +23,26 @@ export declare const registrationFromLayer: <R>(input: {
     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 layer: {
+    (): Layer.Layer<Service>;
+    (options?: GovernanceOptions): (initialRegistrations?: ReadonlyArray<Registration>) => Layer.Layer<Service>;
+    (initialRegistrations?: ReadonlyArray<Registration>, options?: GovernanceOptions): Layer.Layer<Service>;
+};
+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>>;
+    (options?: GovernanceOptions): <E, R>(registrations: ReadonlyArray<Effect.Effect<Registration, E, R>>) => Layer.Layer<Service, E, Exclude<R, import("effect/Scope").Scope>>;
+};
+export declare const memoryLayer: typeof layer;
 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 resolve: (selection: Agent.ModelSelection) => Effect.Effect<ModelRegistry.Registration, ModelRegistry.LanguageModelNotRegistered, 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 declare const provide: {
+    <A, E, R>(selection: Agent.ModelSelection, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | LanguageModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+    (selection: Agent.ModelSelection): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | LanguageModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+};
+export declare const provideForAgent: {
+    <A, E, R>(agent: Agent.Definition, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | LanguageModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+    (agent: Agent.Definition): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | LanguageModelNotRegistered, Service | Exclude<R, ModelEnvironment>>;
+};
 export {};

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

@@ -2,7 +2,7 @@ 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>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/model/model-call-policy/Service", ModelResilience.Interface>;
 export declare class Service extends Service_base {
 }
 export declare const defaultClassify: (error: unknown) => Classification;

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

@@ -6,7 +6,10 @@ export declare const recordWaitTransitioned: (state: string) => Effect.Effect<vo
 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 recordEventReplayed: {
+    (source: string, count: number): Effect.Effect<void>;
+    (count: number): (source: string) => Effect.Effect<void>;
+};
 export declare const recordRunnerReadinessChecked: (database: string) => Effect.Effect<void, never, never>;
 export declare const recordModelUsage: (input: {
     readonly provider: string;
@@ -15,5 +18,11 @@ export declare const recordModelUsage: (input: {
     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>;
+export declare const recordToolCall: {
+    (tool: string, outcome: "success" | "failure" | "denied" | "wait"): Effect.Effect<void>;
+    (outcome: "success" | "failure" | "denied" | "wait"): (tool: string) => Effect.Effect<void>;
+};
+export declare const recordExecutionDuration: {
+    (status: string, durationMillis: number): Effect.Effect<void>;
+    (durationMillis: number): (status: string) => Effect.Effect<void>;
+};

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

@@ -17,7 +17,7 @@ export interface Interface {
     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>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/presence/presence-service/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const PresenceIdentity: Context.Reference<Shared.Metadata>;

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

@@ -10,7 +10,7 @@ export declare const Input: Schema.Struct<{
     }>>;
 }>;
 export declare const Output: Schema.Struct<{
-    readonly watcher_count: Schema.Number;
+    readonly watcher_count: Schema.Finite;
     readonly entries: Schema.$Array<Schema.Struct<{
         readonly id: Schema.String;
         readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;