@relayfx/sdk 0.0.39 → 0.0.40

package/dist/types/runtime/content/blob-store-service.d.ts

@@ -4,25 +4,13 @@ declare const BlobNotResolvable_base: Schema.Class<BlobNotResolvable, Schema.Tag
     readonly uri: Schema.String;
     readonly reason: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/**
- * @experimental
- */
 export declare class BlobNotResolvable extends BlobNotResolvable_base {
 }
 declare const BlobStoreError_base: Schema.Class<BlobStoreError, Schema.TaggedStruct<"BlobStoreError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
-/**
- * @experimental
- */
 export declare class BlobStoreError extends BlobStoreError_base {
 }
-/**
- * What a resolved blob looks like to the loop. `Url` means "pass this through to
- * the provider as-is"; `Bytes` means "hand these bytes to the provider".
- *
- * @experimental
- */
 export type ResolvedBlob = {
     readonly _tag: "Bytes";
     readonly bytes: Uint8Array;
@@ -34,41 +22,20 @@ export type ResolvedBlob = {
     readonly mediaType: string;
     readonly fileName?: string;
 };
-/**
- * @experimental
- */
 export interface PutBlobInput {
     readonly bytes: Uint8Array;
     readonly mediaType: string;
     readonly fileName?: string;
     readonly metadata?: Shared.Metadata;
 }
-/**
- * @experimental
- */
 export interface Interface {
     readonly resolve: (part: Content.BlobReferencePart) => Effect.Effect<ResolvedBlob, BlobNotResolvable | BlobStoreError>;
     readonly put: (input: PutBlobInput) => Effect.Effect<Content.BlobReferencePart, BlobStoreError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/BlobStore", Interface>;
-/**
- * @experimental
- */
 export declare class Service extends Service_base {
 }
-/**
- * Default store: preserves today's behavior bit-for-bit. `resolve` returns the
- * reference uri as a passthrough `Url`; `put` is unsupported.
- *
- * @experimental
- */
 export declare const passthroughLayer: Layer.Layer<Service>;
-/**
- * In-memory store. `put` mints monotonic `memory://blob/<n>` uris (no
- * `Math.random`); `resolve` fails typed when the uri is unknown.
- *
- * @experimental
- */
 export declare const memoryLayer: Layer.Layer<Service>;
 /**
  * Wraps a custom store implementation as a layer.

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

@@ -1,8 +1,8 @@
 import { Envelope, Execution, Ids } from "../../schema/index";
 import { EnvelopeRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as AddressBook from "../address/address-book-service";
-import * as EventLog from "../execution/event-log-service";
+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">;
@@ -45,8 +45,8 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EnvelopeService", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | AddressBook.Service | EventLog.Service>;
-export declare const memoryLayer: (routes?: Iterable<readonly [Ids.AddressId, AddressBook.Route]>) => Layer.Layer<Service, never, never>;
+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, EnvelopeAddressNotFound | EnvelopeRouteUnavailable | EnvelopeRouteDeferred | EnvelopeServiceError, Service>;
 export {};

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

@@ -41,11 +41,6 @@ export interface Interface {
     readonly findByCursor: (input: FindByCursorInput) => 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>;
-    /**
-     * Total tokens (input + output) reported across every `model.usage.reported`
-     * event for the execution. Used to seed per-agent budget accounting on resume
-     * without replaying the full log.
-     */
     readonly sumUsage: (executionId: Ids.ExecutionId) => Effect.Effect<number, EventLogError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/EventLog", Interface>;

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

@@ -2,8 +2,9 @@ import { Agent, Envelope, Execution, Ids, Shared } from "../../schema/index";
 import { ExecutionRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Schema, Stream } from "effect";
 import { ShardingConfig } from "effect/unstable/cluster";
-import * as ChildRunService from "../child/child-run-service";
-import * as EventLog from "./event-log-service";
+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>;
@@ -17,9 +18,9 @@ export interface AcceptInput {
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly createdAt: number;
     readonly agentId?: Ids.AgentId;
-    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
-    readonly agentDefinitionSnapshot?: Agent.Definition;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly agentRevision?: Agent.DefinitionRevision;
+    readonly agentSnapshot?: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly metadata?: Shared.Metadata;
 }
 export interface RunInput {
@@ -47,12 +48,12 @@ export interface Interface {
     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: EventLog.ReplayInput) => Stream.Stream<Execution.ExecutionEvent, 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 | EventLog.Service | ChildRunService.Service | ShardingConfig.ShardingConfig>;
+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>;
@@ -60,5 +61,5 @@ export declare const run: (input: RunInput) => Effect.Effect<Execution.Execution
 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: EventLog.ReplayInput) => Stream.Stream<Execution.ExecutionEvent, ExecutionServiceError, Service>;
+export declare const stream: (input: ReplayInput) => Stream.Stream<Execution.ExecutionEvent, ExecutionServiceError, Service>;
 export {};

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

@@ -1,19 +1,20 @@
 import { Memory } from "@batonfx/core";
 import { MemoryRepository } from "../../store-sql/index";
 import { Context, Effect, Layer } from "effect";
-import * as EmbeddingModelService from "../model/embedding-model-service";
+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?: EmbeddingModelService.ModelSelection | 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 | EmbeddingModelService.Service>;
-export declare const memoryLayer: (options?: Options) => Layer.Layer<Service | Memory.Memory, never, MemoryRepository.Service | EmbeddingModelService.Service>;
+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>;

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

@@ -1,6 +1,6 @@
 import { Agent, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Ai from "effect/unstable/ai";
+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;
@@ -13,7 +13,7 @@ export interface ModelSelection {
     readonly model: string;
     readonly registrationKey?: string | undefined;
 }
-export type ModelEnvironment = Ai.EmbeddingModel.EmbeddingModel | Ai.EmbeddingModel.Dimensions | Ai.Model.ProviderName | Ai.Model.ModelName;
+export type ModelEnvironment = EmbeddingModel.EmbeddingModel | EmbeddingModel.Dimensions | Model.ProviderName | Model.ModelName;
 export interface Registration {
     readonly provider: string;
     readonly model: string;
@@ -57,7 +57,7 @@ export declare const layer: (initialRegistrations?: ReadonlyArray<Registration>,
 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<Ai.EmbeddingModel.EmbeddingModel | Ai.EmbeddingModel.Dimensions, 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>;

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

@@ -1,28 +1,12 @@
-/**
- * @deprecated Delegates to `@batonfx/core` `ModelRegistry`. Import Baton's
- * `ModelRegistry` directly in new code; this module remains only so existing
- * Relay runtime consumers keep their `Agent.ModelSelection`-based surface.
- */
 import { ModelRegistry } from "@batonfx/core";
 import { Agent } from "../../schema/index";
 import { Context, Effect, Layer } from "effect";
-/** @deprecated Use `ModelRegistry.LanguageModelNotRegistered`. */
 export declare const LanguageModelNotRegistered: typeof ModelRegistry.LanguageModelNotRegistered;
-/** @deprecated Use `ModelRegistry.LanguageModelNotRegistered`. */
 export type LanguageModelNotRegistered = ModelRegistry.LanguageModelNotRegistered;
-/** @deprecated Use `ModelRegistry.Registration`. */
 export type Registration = ModelRegistry.Registration;
-/**
- * Throughput governance for the model registry layer.
- *
- * @deprecated Use `ModelRegistry.GovernanceOptions`.
- */
 export type GovernanceOptions = ModelRegistry.GovernanceOptions;
-/** @deprecated Use `ModelRegistry.RegisterInput`. */
 export type RegisterInput = ModelRegistry.RegisterInput;
-/** @deprecated Use `ModelRegistry.ModelEnvironment`. */
 export type ModelEnvironment = ModelRegistry.ModelEnvironment;
-/** @deprecated Use `ModelRegistry.Interface`. */
 export interface Interface {
     readonly register: (input: RegisterInput) => Effect.Effect<void>;
     readonly registrations: Effect.Effect<ReadonlyArray<Registration>>;
@@ -30,14 +14,8 @@ export interface Interface {
     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>;
-/** @deprecated Use `ModelRegistry.Service`. */
 export declare class Service extends Service_base {
 }
-/**
- * @deprecated Use `ModelRegistry.registrationFromLayer`. Note the `metadata`
- * parameter type widens from `Shared.Metadata` to `ModelRegistry.Metadata`,
- * which `Shared.Metadata` satisfies.
- */
 export declare const registrationFromLayer: <R>(input: {
     readonly provider: string;
     readonly model: string;
@@ -45,20 +23,12 @@ 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>;
-/** @deprecated Use `ModelRegistry.layer`. */
 export declare const layer: (initialRegistrations?: ReadonlyArray<Registration>, options?: GovernanceOptions) => Layer.Layer<Service, never, never>;
-/** @deprecated Use `ModelRegistry.layerFromRegistrationEffects`. */
 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>>;
-/** @deprecated Use `ModelRegistry.memoryLayer`. */
 export declare const memoryLayer: (initialRegistrations?: ReadonlyArray<Registration>, options?: GovernanceOptions) => Layer.Layer<Service, never, never>;
-/** @deprecated Use `ModelRegistry.testLayer`. */
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-/** @deprecated Use `ModelRegistry.register`. */
 export declare const register: (input: ModelRegistry.RegisterInput) => Effect.Effect<void, never, Service>;
-/** @deprecated Use `ModelRegistry.registrations`. */
 export declare const registrations: () => Effect.Effect<readonly ModelRegistry.Registration[], never, Service>;
-/** @deprecated Use `ModelRegistry.provide`. */
 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>>;
-/** @deprecated Use `ModelRegistry.provide` with the agent's model selection. */
 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

@@ -1,72 +1,14 @@
 import { ModelResilience } from "@batonfx/core";
 import { Context, Layer, Schedule } from "effect";
-/**
- * Shim over `@batonfx/core`'s `ModelResilience` seam. Baton's `Agent.stream`
- * resolves `ModelResilience.ModelResilience` via `Effect.serviceOption` and
- * applies `ModelResilience.apply` to the model internally, so Relay no longer
- * hand-wraps the model with its own retry logic (see `agent-loop-service.ts`,
- * which resolves this policy and re-provides it under Baton's own tag —
- * `Baton.ModelResilience.ModelResilience` — for the duration of a run).
- *
- * This module keeps its own local service tag (rather than re-exporting
- * Baton's tag directly) because `@batonfx/core` ships its `exports` field
- * pointed at TS source under `node_modules`; a re-exported tag's nominal type
- * resolves to that nested source path, which `tsc --declaration` cannot name
- * portably from deeply composed call sites (TS2742) such as
- * `runner-runtime-service.ts`'s layer-composition helpers. Keeping a local,
- * package-owned tag avoids that while still sharing Baton's `Interface`
- * shape, `Classification` type, and `defaultClassify` implementation
- * one-for-one — and `agent-loop-service.ts` explicitly re-provides the
- * resolved policy under Baton's tag at the one call site that needs it, so
- * the two tags never need to be identical for Baton to see the seam.
- *
- * Preserves every historical export name and Relay's historical default
- * schedule (jittered exponential from 1s, up to 4 retries) — Baton's own
- * `ModelResilience.make()` defaults to `Schedule.recurs(0)` (no retry), so
- * Relay must keep supplying its own default or retries silently vanish.
- *
- * @experimental
- */
 export type Classification = ModelResilience.Classification;
-/**
- * @experimental
- */
 export type Interface = ModelResilience.Interface;
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/ModelCallPolicy", ModelResilience.Interface>;
-/**
- * @experimental
- */
 export declare class Service extends Service_base {
 }
-/**
- * Default classification: malformed model output is terminal, other failures follow Baton.
- *
- * @experimental
- */
 export declare const defaultClassify: (error: unknown) => Classification;
-/**
- * Default schedule: jittered exponential from 1s, at most 4 retries. Relay's
- * historical default — Baton's own default is `Schedule.recurs(0)` (no retry).
- *
- * @experimental
- */
 export declare const defaultSchedule: Schedule.Schedule<unknown>;
-/**
- * @experimental
- */
 export declare const make: (input?: Partial<Interface>) => Interface;
-/**
- * @experimental
- */
 export declare const layer: (input?: Partial<Interface>) => Layer.Layer<Service, never, never>;
-/**
- * Never retries — useful for tests that assert single-attempt behavior.
- *
- * @experimental
- */
 export declare const noRetryLayer: Layer.Layer<Service, never, never>;
-/**
- * @experimental
- */
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export {};