@relayfx/sdk 0.3.0 → 0.3.2

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

@@ -0,0 +1,44 @@
+export * from "../runtime/tool/tool-runtime-contract";
+import type { DynamicToolOptions, Interface, PlacedToolOptions, RegisteredTool, RunError, RunInput, Service, ToolkitRegistrationOptions, ToolOptions } from "../runtime/tool/tool-runtime-contract";
+import { Context, Effect, Layer, Schema } from "effect";
+import type { Tool as AiTool, Toolkit } from "effect/unstable/ai";
+import type { Tool } from "../schema/index";
+export declare const tool: {
+    <const Name extends string, Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(name: Name, options: ToolOptions<Input, Output>): RegisteredTool;
+    <Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(options: ToolOptions<Input, Output>): <const Name extends string>(name: Name) => RegisteredTool;
+};
+export declare const dynamicTool: {
+    <const Name extends string>(name: Name, options: DynamicToolOptions): RegisteredTool;
+    (options: DynamicToolOptions): <const Name extends string>(name: Name) => RegisteredTool;
+};
+export declare const clientTool: {
+    (modelTool: AiTool.Any, options?: PlacedToolOptions): RegisteredTool;
+    (options?: PlacedToolOptions): (modelTool: AiTool.Any) => RegisteredTool;
+};
+export declare const remoteTool: {
+    (modelTool: AiTool.Any, options: PlacedToolOptions & {
+        readonly queue: Tool.PlacementKey;
+    }): RegisteredTool;
+    (options: PlacedToolOptions & {
+        readonly queue: Tool.PlacementKey;
+    }): (modelTool: AiTool.Any) => RegisteredTool;
+};
+export interface HostInterface {
+    readonly registeredTools: Effect.Effect<ReadonlyArray<RegisteredTool>>;
+}
+declare const HostService_base: Context.ServiceClass<HostService, "@relayfx/sdk/tool-runtime/HostService", HostInterface>;
+export declare class HostService extends HostService_base {
+}
+export declare const memoryLayer: (tools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<Service>;
+/** Consumer tool registration layer. Runtime persistence is supplied by `Runtime.layerEmbedded` or `Runtime.layerRunner`. */
+export declare const layer: (tools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<HostService>;
+export declare const memoryLayerFromToolkit: {
+    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<Service, never, AiTool.HandlersFor<Tools>>;
+    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<Service, never, AiTool.HandlersFor<Tools>>;
+};
+export declare const layerFromToolkit: {
+    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<HostService, never, AiTool.HandlersFor<Tools>>;
+    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<HostService, never, AiTool.HandlersFor<Tools>>;
+};
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, RunError, Service>;

package/dist/types/relay/tool-worker.d.ts

@@ -1,7 +1,7 @@
 import { Shared, Tool } from "../schema/index";
 import { Duration, Effect } from "effect";
-import { Service as ClientService } from "./client";
-import type { ClientError } from "./client";
+import { Service as ClientService } from "./client-public";
+import type { ClientError } from "./client-public";
 import type { ToolWorkLease } from "./operation";
 export interface HandlerContext {
     readonly lease: ToolWorkLease;

package/dist/types/relay/workflow-definition-host.d.ts

@@ -0,0 +1,32 @@
+import { Ids, Shared, Workflow } from "../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+export declare const SideEffectContext: Schema.Struct<{
+    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 operation_id: Schema.brand<Schema.String, "Relay.WorkflowOperationId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
+    };
+    readonly idempotency_key: Schema.String;
+}>;
+export interface SideEffectContext extends Schema.Schema.Type<typeof SideEffectContext> {
+}
+declare const HandlerError_base: Schema.Class<HandlerError, Schema.TaggedStruct<"WorkflowDefinitionHostHandlerError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HandlerError extends HandlerError_base {
+}
+export interface Handlers {
+    readonly tool?: (executionId: Ids.ExecutionId, operation: typeof Workflow.ToolOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, HandlerError>;
+    readonly child: (executionId: Ids.ExecutionId, operation: typeof Workflow.ChildOperation.Type | typeof Workflow.DispatchableChildOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, HandlerError>;
+    readonly approval: (executionId: Ids.ExecutionId, operation: typeof Workflow.ApprovalOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, HandlerError>;
+    readonly timer: (executionId: Ids.ExecutionId, operation: typeof Workflow.TimerOperation.Type, context: SideEffectContext) => Effect.Effect<void, HandlerError>;
+    readonly branch: (executionId: Ids.ExecutionId, operation: typeof Workflow.BranchOperation.Type, context: SideEffectContext) => Effect.Effect<boolean, HandlerError>;
+    readonly structuredCompletion: (schemaRef: string, value: Shared.JsonValue | undefined, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, HandlerError>;
+}
+export type Interface = Handlers;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/workflow-definition-host/Service", Handlers>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (handlers: Handlers) => Layer.Layer<Service, never, never>;
+export {};

package/dist/types/runtime/agent/agent-loop-error.d.ts

@@ -0,0 +1,21 @@
+import { AgentEvent, ModelRegistry, ToolExecutor, TurnPolicy } from "@batonfx/core";
+import { Schema } from "effect";
+import { AiError } from "effect/unstable/ai";
+declare const AgentLoopError_base: Schema.Class<AgentLoopError, Schema.TaggedStruct<"AgentLoopError", {
+    readonly message: Schema.String;
+    readonly failure_classification: Schema.optionalKey<Schema.Literal<"context-overflow">>;
+    readonly baton_failure: Schema.optionalKey<Schema.Union<readonly [typeof AgentEvent.AgentError, typeof AgentEvent.ResumeMismatch, typeof TurnPolicy.TurnPolicyError, typeof AgentEvent.TurnPolicyStopped, typeof AgentEvent.TurnLimitExceeded, typeof AgentEvent.MiddlewareViolation, typeof AgentEvent.DuplicateToolCallId, typeof AgentEvent.ProgressOverflowError, typeof AgentEvent.ToolNameCollision, typeof AiError.AiError, typeof ModelRegistry.LanguageModelNotRegistered, typeof ToolExecutor.FrameworkFailure]>>;
+    readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentLoopError extends AgentLoopError_base {
+}
+declare const AgentLoopBudgetExceeded_base: Schema.Class<AgentLoopBudgetExceeded, Schema.TaggedStruct<"AgentLoopBudgetExceeded", {
+    readonly tokens_used: Schema.Int;
+    readonly token_budget: Schema.Int;
+    readonly next_event_sequence: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentLoopBudgetExceeded extends AgentLoopBudgetExceeded_base {
+}
+export declare const AgentTerminalFailure: Schema.Union<readonly [typeof AgentLoopError, typeof AgentLoopBudgetExceeded]>;
+export type AgentTerminalFailure = typeof AgentTerminalFailure.Type;
+export {};

package/dist/types/runtime/agent/agent-loop-service.d.ts

@@ -1,3 +1,4 @@
+import { AgentEvent, ModelRegistry } from "@batonfx/core";
 import { Agent, Content, Execution, Ids, Shared, Tool } from "../../schema/index";
 import { AgentChatRepository } from "../../store-sql/portable";
 import { Cause, Context, Effect, Layer, Schema } from "effect";
@@ -10,12 +11,8 @@ import { Service as SchemaRegistryService } from "../schema-registry/schema-regi
 import { Service as ToolRuntimeService } from "../tool/tool-runtime-service";
 import type { ToolRuntimeError } from "../tool/tool-runtime-service";
 import { Service as PromptAssemblerService } from "./prompt-assembler-service";
-declare const AgentLoopError_base: Schema.Class<AgentLoopError, Schema.TaggedStruct<"AgentLoopError", {
-    readonly message: Schema.String;
-    readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
-}>, Cause.YieldableError>;
-export declare class AgentLoopError extends AgentLoopError_base {
-}
+import { AgentLoopBudgetExceeded, AgentLoopError } from "./agent-loop-error";
+export { AgentLoopBudgetExceeded, AgentLoopError, AgentTerminalFailure } from "./agent-loop-error";
 declare const AgentLoopWaitRequested_base: Schema.Class<AgentLoopWaitRequested, Schema.TaggedStruct<"AgentLoopWaitRequested", {
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
@@ -28,17 +25,11 @@ declare const AgentLoopWaitRequested_base: Schema.Class<AgentLoopWaitRequested,
         readonly input: 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 suspension: typeof AgentEvent.AgentSuspended;
     readonly next_event_sequence: Schema.Int;
 }>, Cause.YieldableError>;
 export declare class AgentLoopWaitRequested extends AgentLoopWaitRequested_base {
 }
-declare const AgentLoopBudgetExceeded_base: Schema.Class<AgentLoopBudgetExceeded, Schema.TaggedStruct<"AgentLoopBudgetExceeded", {
-    readonly tokens_used: Schema.Int;
-    readonly token_budget: Schema.Int;
-    readonly next_event_sequence: Schema.Int;
-}>, Cause.YieldableError>;
-export declare class AgentLoopBudgetExceeded extends AgentLoopBudgetExceeded_base {
-}
 export interface RunInput {
     readonly executionId: Ids.ExecutionId;
     readonly sessionId?: Ids.SessionId;
@@ -47,7 +38,7 @@ export interface RunInput {
     readonly agentRevision?: Agent.DefinitionRevision;
     readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly input: ReadonlyArray<Content.Part>;
-    readonly resumeToolCall?: Tool.Call;
+    readonly resumeSuspension?: AgentEvent.AgentSuspended;
     readonly memorySubjectId?: Ids.MemorySubjectId;
     readonly eventSequence: Execution.ExecutionEventSequence;
     readonly startedAt: number;
@@ -84,9 +75,8 @@ export declare const toolFromDefinition: (definition: Tool.Definition) => AiTool
 /** Map a Baton run failure (or an upstream model error) to the public error types. */
 export declare const mapBoundaryError: {
     (current: Execution.ExecutionEventSequence): (error: unknown) => AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
-    (error: unknown, current: Execution.ExecutionEventSequence): AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
+    (error: unknown, current: Execution.ExecutionEventSequence, failureClassification?: ModelRegistry.FailureClassification): AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
 };
 export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLogService | ToolRuntimeService | LanguageModelServiceService | ModelCallPolicyService | SchemaRegistryService | PromptAssemblerService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopBudgetExceeded | AgentLoopError | AgentLoopWaitRequested, Service>;
-export {};

package/dist/types/runtime/agent/prompt-assembler-service.d.ts

@@ -31,16 +31,16 @@ export declare const contentToPromptPart: (part: PureContentPart) => Prompt.User
  * Default assembler that resolves reference content parts through the
  * {@link BlobStore} and {@link ArtifactStore} it reads from context. Requires
  * both stores to be provided (`runner-runtime-service.ts` wires passthrough
- * stores by default; see `docs/spec/29-blob-and-artifact-stores.md`).
+ * stores by default; see `docs/features/agents-and-tools.md`).
  *
  * @experimental
  */
 export declare const defaultLayerWithStores: Layer.Layer<Service, never, BlobStoreService | ArtifactStoreService>;
 /**
  * Default assembler: reproduces the agent loop's historical prompt construction,
- * minus the model-selection dump (see `docs/spec/28-prompt-assembly.md`).
+ * minus the model-selection dump (see `docs/features/agents-and-tools.md`).
  * Bakes in passthrough stores so it stays self-contained and behavior is
- * preserved bit-for-bit (see `docs/spec/29-blob-and-artifact-stores.md`).
+ * preserved bit-for-bit (see `docs/features/agents-and-tools.md`).
  *
  * @experimental
  */

package/dist/types/runtime/cluster/execution-entity.d.ts

@@ -4,13 +4,13 @@ import { Rpc } from "effect/unstable/rpc";
 import type { WorkflowEngine } from "effect/unstable/workflow";
 import { Schema } from "effect";
 import type { Effect } from "effect";
-import { ExecutionWorkflowFailed, StartInput, StartResult } from "../workflow/execution-workflow";
+import { ExecutionWorkflowError, ExecutionWorkflowFailed, StartInput, StartResult } from "../workflow/execution-workflow";
 import type { Service as ActiveExecutionRegistryService } from "../execution/active-execution-registry";
 import type { Service as EventLogService } from "../execution/event-log-service";
 import type { Service as ExecutionServiceService } from "../execution/execution-service";
 import type { Service as ToolTransitionCoordinatorService } from "../tool/tool-transition-coordinator";
 import type { Service as WaitServiceService } from "../wait/wait-service";
-export declare const Start: Rpc.Rpc<"start", typeof StartInput, typeof StartResult, typeof ExecutionWorkflowFailed>;
+export declare const Start: Rpc.Rpc<"start", typeof StartInput, typeof StartResult, typeof ExecutionWorkflowError>;
 export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly workflow_execution_id: Schema.String;
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
@@ -19,7 +19,7 @@ export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
     readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
     readonly signaled_at: Schema.Int;
 }>, Schema.Void, typeof ExecutionWorkflowFailed, never, never>;
-export declare const Dispatch: Rpc.Rpc<"dispatch", typeof StartInput, typeof Schema.Void, typeof ExecutionWorkflowFailed>;
+export declare const Dispatch: Rpc.Rpc<"dispatch", typeof StartInput, typeof Schema.Void, typeof ExecutionWorkflowError>;
 export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;

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

@@ -5,8 +5,11 @@ 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";
+export declare const ExecutionServiceErrorDetails: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+export type ExecutionServiceErrorDetails = typeof ExecutionServiceErrorDetails.Type;
 declare const ExecutionServiceError_base: Schema.Class<ExecutionServiceError, Schema.TaggedStruct<"ExecutionServiceError", {
     readonly message: Schema.String;
+    readonly details: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ExecutionServiceError extends ExecutionServiceError_base {

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

@@ -25,6 +25,7 @@ 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 ModelHub from "./model/model-hub";
 export * as MemoryService from "./memory/memory-service";
 export * as ModelCallPolicy from "./model/model-call-policy";
 export * as ParentNotifier from "./child/parent-notifier-service";

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

@@ -1,12 +1,13 @@
 import { ModelRegistry } from "@batonfx/core";
 import { Agent } from "../../schema/index";
 import { Context, Effect, Layer } from "effect";
+import { LanguageModel, Model } from "effect/unstable/ai";
 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 type ModelEnvironment = LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName;
 export interface Interface {
     readonly register: (input: RegisterInput) => Effect.Effect<void>;
     readonly registrations: Effect.Effect<ReadonlyArray<Registration>>;
@@ -20,19 +21,11 @@ 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 layer: Layer.Layer<LanguageModel.LanguageModel, never, R>;
     readonly metadata?: ModelRegistry.Metadata;
+    readonly classifyFailure?: ModelRegistry.FailureClassifier;
 }) => 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 fromModelRegistry: (registry: ModelRegistry.Interface) => Interface;
 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>;

package/dist/types/runtime/model/model-hub.d.ts

@@ -0,0 +1,27 @@
+import { ModelRegistry } from "@batonfx/core";
+import { Context, Effect, Layer, Schema } from "effect";
+import { type Interface as LanguageModelServiceInterface, Service as LanguageModelService } from "./language-model-service";
+declare const ModelRegistrationCollision_base: Schema.Class<ModelRegistrationCollision, Schema.TaggedStruct<"ModelRegistrationCollision", {
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    readonly registration_key: Schema.optionalKey<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ModelRegistrationCollision extends ModelRegistrationCollision_base {
+}
+export interface Interface {
+    readonly modelRegistry: ModelRegistry.Interface;
+    readonly languageModelService: LanguageModelServiceInterface;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/model/model-hub/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: {
+    (registrations: ReadonlyArray<ModelRegistry.Registration>, options?: ModelRegistry.GovernanceOptions): Layer.Layer<Service | LanguageModelService | ModelRegistry.Service, ModelRegistrationCollision>;
+    (options?: ModelRegistry.GovernanceOptions): (registrations: ReadonlyArray<ModelRegistry.Registration>) => Layer.Layer<Service | LanguageModelService | ModelRegistry.Service, ModelRegistrationCollision>;
+};
+export declare const layerFromRegistrationEffects: {
+    <E, R>(declarations: ReadonlyArray<Effect.Effect<ModelRegistry.Registration, E, R>>, options?: ModelRegistry.GovernanceOptions): Layer.Layer<Service | LanguageModelService | ModelRegistry.Service, E | ModelRegistrationCollision, Exclude<R, import("effect/Scope").Scope>>;
+    (options?: ModelRegistry.GovernanceOptions): <E, R>(declarations: ReadonlyArray<Effect.Effect<ModelRegistry.Registration, E, R>>) => Layer.Layer<Service | LanguageModelService | ModelRegistry.Service, E | ModelRegistrationCollision, Exclude<R, import("effect/Scope").Scope>>;
+};
+export declare const testLayer: (modelRegistry: ModelRegistry.Interface) => Layer.Layer<ModelRegistry.Service | LanguageModelService | Service, never, never>;
+export {};

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

@@ -0,0 +1,24 @@
+import { Presence, Shared } from "../../schema/index";
+import { Context, Effect, 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>;
+}
+export type Identifier = "@relayfx/runtime/presence/presence-contract/Service";
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/presence/presence-contract/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const PresenceIdentity: Context.Reference<Shared.Metadata>;
+export {};

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

@@ -1,30 +1,12 @@
-import { Presence, Shared } from "../../schema/index";
+import { Presence } from "../../schema/index";
 import { PresenceRepository } from "../../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>;
+import { Config, Effect, Layer, Stream } from "effect";
+export * from "./presence-contract";
+import { PresenceError, Service } from "./presence-contract";
+import type { Interface, RegisterInput } from "./presence-contract";
 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 register: (input: RegisterInput) => Effect.Effect<void, never, import("effect/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 {};