@relayfx/test 0.3.1 → 0.3.2

package/dist/types/runtime/entity/entity-instance-service.d.ts

@@ -1,76 +0,0 @@
-import { Content, Entity, Ids, Shared } from "../../schema/index";
-import { EntityRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as AddressBookService } from "../address/address-book-service";
-import { Service as AgentRegistryService } from "../agent/agent-registry-service";
-import { Service as EventLogService } from "../execution/event-log-service";
-import { EntityKindInvalid, EntityKindNotFound, Service as EntityRegistryService } from "./entity-registry-service";
-declare const EntityDestroyed_base: Schema.Class<EntityDestroyed, Schema.TaggedStruct<"EntityDestroyed", {
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
-    };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class EntityDestroyed extends EntityDestroyed_base {
-}
-declare const EntityNotFound_base: Schema.Class<EntityNotFound, Schema.TaggedStruct<"EntityNotFound", {
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
-    };
-    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class EntityNotFound extends EntityNotFound_base {
-}
-declare const EntityServiceError_base: Schema.Class<EntityServiceError, Schema.TaggedStruct<"EntityServiceError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class EntityServiceError extends EntityServiceError_base {
-}
-export interface GetOrCreateInput {
-    readonly kind: Ids.EntityKindName;
-    readonly key: Ids.EntityKey;
-    readonly input?: ReadonlyArray<Content.Part>;
-    readonly metadata?: Shared.Metadata;
-    readonly createdAt: number;
-}
-export interface Interface {
-    readonly getOrCreate: (input: GetOrCreateInput) => Effect.Effect<Entity.Instance, EntityKindNotFound | EntityKindInvalid | EntityServiceError>;
-    readonly get: (input: {
-        readonly kind: Ids.EntityKindName;
-        readonly key: Ids.EntityKey;
-    }) => Effect.Effect<Entity.Instance | undefined, EntityServiceError>;
-    readonly destroy: (input: {
-        readonly kind: Ids.EntityKindName;
-        readonly key: Ids.EntityKey;
-        readonly reason?: string;
-        readonly destroyedAt: number;
-    }) => Effect.Effect<Entity.Instance, EntityNotFound | EntityDestroyed | EntityServiceError>;
-    readonly list: (input: {
-        readonly kind?: Ids.EntityKindName;
-        readonly afterKind?: Ids.EntityKindName;
-        readonly afterKey?: string;
-        readonly limit?: number;
-    }) => Effect.Effect<ReadonlyArray<Entity.Instance>, EntityServiceError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/entity/entity-instance-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const entityExecutionId: {
-    (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey, generation: number): Ids.ExecutionId;
-    (kind: Ids.EntityKindName, key: Ids.EntityKey, generation: number): (tenant: Ids.TenantId) => Ids.ExecutionId;
-};
-export declare const entityAddressId: {
-    (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey): Ids.AddressId;
-    (kind: Ids.EntityKindName, key: Ids.EntityKey): (tenant: Ids.TenantId) => Ids.AddressId;
-};
-export declare const entitySessionId: {
-    (tenant: Ids.TenantId, kind: Ids.EntityKindName, key: Ids.EntityKey): Ids.SessionId;
-    (kind: Ids.EntityKindName, key: Ids.EntityKey): (tenant: Ids.TenantId) => Ids.SessionId;
-};
-export declare const layer: Layer.Layer<Service, never, EntityRepository.Service | AddressBookService | EventLogService | AgentRegistryService | EntityRegistryService | import("effect/unstable/cluster/Sharding").Sharding>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export {};

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

@@ -1,35 +0,0 @@
-import { Entity, Ids } from "../../schema/index";
-import { EntityRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as AgentRegistryService } from "../agent/agent-registry-service";
-declare const EntityKindNotFound_base: Schema.Class<EntityKindNotFound, Schema.TaggedStruct<"EntityKindNotFound", {
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class EntityKindNotFound extends EntityKindNotFound_base {
-}
-declare const EntityKindInvalid_base: Schema.Class<EntityKindInvalid, Schema.TaggedStruct<"EntityKindInvalid", {
-    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
-    };
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class EntityKindInvalid extends EntityKindInvalid_base {
-}
-declare const EntityRegistryError_base: Schema.Class<EntityRegistryError, Schema.TaggedStruct<"EntityRegistryError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class EntityRegistryError extends EntityRegistryError_base {
-}
-export interface Interface {
-    readonly registerKind: (input: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, EntityKindInvalid | EntityRegistryError>;
-    readonly getKind: (kind: Ids.EntityKindName) => Effect.Effect<Entity.KindDefinition | undefined, EntityRegistryError>;
-    readonly listKinds: Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRegistryError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/entity/entity-registry-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, EntityRepository.Service | AgentRegistryService>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export {};

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

@@ -1,56 +0,0 @@
-import { Envelope, Execution, Ids } from "../../schema/index";
-import { EnvelopeRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Route, Service as AddressBookService } from "../address/address-book-service";
-import { Service as EventLogService } from "../execution/event-log-service";
-declare const EnvelopeAddressNotFound_base: Schema.Class<EnvelopeAddressNotFound, Schema.TaggedStruct<"EnvelopeAddressNotFound", {
-    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 EnvelopeAddressNotFound extends EnvelopeAddressNotFound_base {
-}
-declare const EnvelopeRouteUnavailable_base: Schema.Class<EnvelopeRouteUnavailable, Schema.TaggedStruct<"EnvelopeRouteUnavailable", {
-    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 EnvelopeRouteUnavailable extends EnvelopeRouteUnavailable_base {
-}
-declare const EnvelopeRouteDeferred_base: Schema.Class<EnvelopeRouteDeferred, Schema.TaggedStruct<"EnvelopeRouteDeferred", {
-    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 EnvelopeRouteDeferred extends EnvelopeRouteDeferred_base {
-}
-declare const EnvelopeServiceError_base: Schema.Class<EnvelopeServiceError, Schema.TaggedStruct<"EnvelopeServiceError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class EnvelopeServiceError extends EnvelopeServiceError_base {
-}
-export interface SendInput {
-    readonly envelopeId: Ids.EnvelopeId;
-    readonly executionId: Ids.ExecutionId;
-    readonly input: Envelope.SendInput;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-    readonly waitId?: Ids.WaitId;
-}
-export interface Interface {
-    readonly send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted & {
-        readonly route_kind?: Route["kind"];
-    }, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/envelope/envelope-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | AddressBookService | EventLogService>;
-export declare const memoryLayer: (routes?: Iterable<readonly [Ids.AddressId, Route]>) => Layer.Layer<Service, never, never>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const send: (input: SendInput) => Effect.Effect<Envelope.EnvelopeAccepted & {
-    readonly route_kind?: Route["kind"];
-}, EnvelopeAddressNotFound | EnvelopeRouteDeferred | EnvelopeRouteUnavailable | EnvelopeServiceError, Service>;
-export {};

package/dist/types/runtime/execution/active-execution-registry.d.ts

@@ -1,12 +0,0 @@
-import { Ids } from "../../schema/index";
-import { Context, Effect, Layer } from "effect";
-export interface Interface {
-    readonly run: <A, E, R>(executionId: Ids.ExecutionId, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-    readonly interrupt: (executionId: Ids.ExecutionId) => Effect.Effect<boolean>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/execution/active-execution-registry/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, never>;
-export declare const testLayer: Layer.Layer<Service, never, never>;
-export {};

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

@@ -1,93 +0,0 @@
-import { Execution, Ids } from "../../schema/index";
-import { ExecutionEventRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
-declare const EventLogCursorNotFound_base: Schema.Class<EventLogCursorNotFound, Schema.TaggedStruct<"EventLogCursorNotFound", {
-    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 cursor: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class EventLogCursorNotFound extends EventLogCursorNotFound_base {
-}
-declare const EventLogError_base: Schema.Class<EventLogError, Schema.TaggedStruct<"EventLogError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class EventLogError extends EventLogError_base {
-}
-export interface ReplayInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly afterCursor?: string;
-    readonly limit?: number;
-}
-export type PageInput = {
-    readonly executionId: Ids.ExecutionId;
-    readonly direction: "forward";
-    readonly afterCursor?: string;
-    readonly beforeCursor?: never;
-    readonly limit?: number;
-} | {
-    readonly executionId: Ids.ExecutionId;
-    readonly direction: "backward";
-    readonly afterCursor?: never;
-    readonly beforeCursor?: string;
-    readonly limit?: number;
-};
-export interface PageResult {
-    readonly events: ReadonlyArray<Execution.ExecutionEvent>;
-    readonly hasMore: boolean;
-    readonly oldestCursor?: string;
-    readonly newestCursor?: string;
-}
-export interface FindBySequenceOrCursorInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly sequence: Execution.ExecutionEventSequence;
-    readonly cursor: string;
-}
-export interface FindByCursorInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly cursor: string;
-}
-export interface FindBySequenceInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly sequence: Execution.ExecutionEventSequence;
-}
-export interface FindFirstByTypeAfterSequenceInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly type: Execution.ExecutionEventType;
-    readonly afterSequence: Execution.ExecutionEventSequence;
-}
-export interface Interface {
-    readonly append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError>;
-    readonly replay: (input: ReplayInput) => Effect.Effect<ReadonlyArray<Execution.ExecutionEvent>, EventLogCursorNotFound | EventLogError>;
-    readonly stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | EventLogError>;
-    readonly page: (input: PageInput) => Effect.Effect<PageResult, EventLogCursorNotFound | EventLogError>;
-    readonly findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
-    readonly findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
-    readonly findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
-    readonly findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError>;
-    readonly maxSequence: (executionId: Ids.ExecutionId) => Effect.Effect<Execution.ExecutionEventSequence | undefined, EventLogError>;
-    readonly sumUsage: (executionId: Ids.ExecutionId) => Effect.Effect<number, EventLogError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/execution/event-log-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layerFromRepository: Layer.Layer<Service, never, ExecutionEventRepository.Service>;
-export declare const memoryLayer: Layer.Layer<Service, never, never>;
-type TestImplementation = Omit<Interface, "page"> & Partial<Pick<Interface, "page">>;
-export declare const testLayer: (implementation: TestImplementation) => Layer.Layer<Service, never, never>;
-export declare const appendIdempotentTo: {
-    (eventLog: Interface, input: Execution.ExecutionEvent): Effect.Effect<Execution.ExecutionEvent, EventLogError>;
-    (input: Execution.ExecutionEvent): (eventLog: Interface) => Effect.Effect<Execution.ExecutionEvent, EventLogError>;
-};
-export declare const append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
-export declare const appendIdempotent: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError, Service>;
-export declare const replay: (input: ReplayInput) => Effect.Effect<readonly Execution.ExecutionEvent[], EventLogCursorNotFound | EventLogError, Service>;
-export declare const page: (input: PageInput) => Effect.Effect<PageResult, EventLogCursorNotFound | EventLogError, Service>;
-export declare const findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
-export declare const findByCursor: (input: FindByCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
-export declare const findBySequence: (input: FindBySequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
-export declare const findFirstByTypeAfterSequence: (input: FindFirstByTypeAfterSequenceInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, EventLogError, Service>;
-export declare const maxSequence: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number | undefined, EventLogError, Service>;
-export declare const sumUsage: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<number, EventLogError, Service>;
-export declare const stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | EventLogError, Service>;
-export {};

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

@@ -1,66 +0,0 @@
-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;
-    readonly metadata?: Shared.Metadata;
-}
-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/execution/execution-service/Service", 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

@@ -1,32 +0,0 @@
-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/execution/execution-watch-service/Service", 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

@@ -1,33 +0,0 @@
-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/execution/session-stream-service/Service", 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

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

@@ -1,27 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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 ChildFanOutAdmission from "./child/child-fan-out-admission-service";
-export * as ChildFanOutTransition from "./child/child-fan-out-transition-service";
-export * as ChildFanOutRuntime from "./child/child-fan-out-runtime";
-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 ActiveExecutionRegistry from "./execution/active-execution-registry";
-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 WorkflowDefinitionRuntime from "./workflow/definition-runtime";
-export * as ActivityVersionRegistry from "./workflow/activity-version-registry";
-export declare const runtimePackage = "./index";

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

@@ -1,22 +0,0 @@
-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/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>;
-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 {};