@relayfx/test 0.3.1 → 0.3.2

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

@@ -1,81 +0,0 @@
-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/model/embedding-model-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const registrationFromLayer: <R>(input: {
-    readonly provider: string;
-    readonly model: string;
-    readonly registrationKey?: string | undefined;
-    readonly layer: Layer.Layer<EmbeddingModel.EmbeddingModel | EmbeddingModel.Dimensions, never, R>;
-    readonly metadata?: Shared.Metadata | undefined;
-}) => Effect.Effect<Registration, never, R>;
-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.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, 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

@@ -1,48 +0,0 @@
-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/model/language-model-service/Service", 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: {
-    (): 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, 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

@@ -1,14 +0,0 @@
-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/model/model-call-policy/Service", 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

@@ -1,28 +0,0 @@
-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>;
-    (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;
-    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>;
-    (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

@@ -1,30 +0,0 @@
-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/presence-service/Service", 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

@@ -1,20 +0,0 @@
-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.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>>;
-        readonly connected_at: Schema.Int;
-    }>>;
-}>;
-export declare const registeredTool: (presence: PresenceInterface) => RegisteredTool;