@relayfx/sdk 0.3.6 → 0.4.0

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

@@ -8,7 +8,7 @@ export interface Config {
     readonly eventLog: EventLogInterface;
     readonly allocator: {
         readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
-        readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
+        readonly advanceTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
     };
     readonly executionId: Ids.ExecutionId;
     readonly permissions: ReadonlyArray<Tool.Permission>;
@@ -18,5 +18,5 @@ export interface Config {
     readonly resumedToolCallId?: Ids.ToolCallId;
     readonly extraTools?: ReadonlyArray<RegisteredTool>;
 }
-export declare const make: (config: Config) => ToolExecutor.Interface;
+export declare const make: (config: Config) => Effect.Effect<ToolExecutor.Interface>;
 export declare const layer: (config: Config) => Layer.Layer<ToolExecutor.ToolExecutor>;

package/dist/types/runtime/agent/sequence-allocator.d.ts

@@ -3,6 +3,7 @@ import { Effect } from "effect";
 export interface SequenceAllocator {
     readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
     readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
+    readonly advanceTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
     readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
 }
 export declare const make: (first: Execution.ExecutionEventSequence) => Effect.Effect<SequenceAllocator>;

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

@@ -0,0 +1,7 @@
+import { Layer } from "effect";
+import type { EventLogCursorNotFound, EventLogError, Service } from "./event-log-service";
+export declare const makeMemoryLayer: (eventLog: {
+    readonly EventLogCursorNotFound: typeof EventLogCursorNotFound;
+    readonly EventLogError: typeof EventLogError;
+    readonly Service: typeof Service;
+}) => Layer.Layer<Service, never, never>;

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

@@ -0,0 +1,8 @@
+import { ExecutionEventRepository } from "../../store-sql/portable";
+import { Layer } from "effect";
+import type { EventLogCursorNotFound, EventLogError, Service } from "./event-log-service";
+export declare const makeRepositoryLayer: (eventLog: {
+    readonly EventLogCursorNotFound: typeof EventLogCursorNotFound;
+    readonly EventLogError: typeof EventLogError;
+    readonly Service: typeof Service;
+}) => Layer.Layer<Service, never, ExecutionEventRepository.Service>;

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

@@ -58,6 +58,7 @@ export interface FindFirstByTypeAfterSequenceInput {
 }
 export interface Interface {
     readonly append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, EventLogError>;
+    readonly appendNext: (input: ExecutionEventRepository.AppendNextInput) => 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>;
@@ -73,13 +74,14 @@ 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">>;
+type TestImplementation = Omit<Interface, "appendNext" | "page"> & Partial<Pick<Interface, "appendNext" | "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 appendNext: (input: ExecutionEventRepository.AppendNextInput) => 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>;

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

@@ -11,8 +11,8 @@ 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 ResidentInstanceService from "./resident/resident-instance-service";
+export * as ResidentRegistry from "./resident/resident-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";

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

@@ -0,0 +1,76 @@
+import { Content, Ids, Resident, Shared } from "../../schema/index";
+import { ResidentRepository } from "../../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 { ResidentKindInvalid, ResidentKindNotFound, Service as ResidentRegistryService } from "./resident-registry-service";
+declare const ResidentDestroyed_base: Schema.Class<ResidentDestroyed, Schema.TaggedStruct<"ResidentDestroyed", {
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentDestroyed extends ResidentDestroyed_base {
+}
+declare const ResidentNotFound_base: Schema.Class<ResidentNotFound, Schema.TaggedStruct<"ResidentNotFound", {
+    readonly kind: Schema.brand<Schema.String, "Relay.ResidentKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.ResidentKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ResidentKey">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentNotFound extends ResidentNotFound_base {
+}
+declare const ResidentServiceError_base: Schema.Class<ResidentServiceError, Schema.TaggedStruct<"ResidentServiceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ResidentServiceError extends ResidentServiceError_base {
+}
+export interface SpawnInput {
+    readonly kind: Ids.ResidentKindName;
+    readonly key: Ids.ResidentKey;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface Interface {
+    readonly spawn: (input: SpawnInput) => Effect.Effect<Resident.Instance, ResidentKindNotFound | ResidentKindInvalid | ResidentServiceError>;
+    readonly get: (input: {
+        readonly kind: Ids.ResidentKindName;
+        readonly key: Ids.ResidentKey;
+    }) => Effect.Effect<Resident.Instance | undefined, ResidentServiceError>;
+    readonly destroy: (input: {
+        readonly kind: Ids.ResidentKindName;
+        readonly key: Ids.ResidentKey;
+        readonly reason?: string;
+        readonly destroyedAt: number;
+    }) => Effect.Effect<Resident.Instance, ResidentNotFound | ResidentDestroyed | ResidentServiceError>;
+    readonly list: (input: {
+        readonly kind?: Ids.ResidentKindName;
+        readonly afterKind?: Ids.ResidentKindName;
+        readonly afterKey?: string;
+        readonly limit?: number;
+    }) => Effect.Effect<ReadonlyArray<Resident.Instance>, ResidentServiceError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/resident/resident-instance-service/Service", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const residentExecutionId: {
+    (tenant: Ids.TenantId, kind: Ids.ResidentKindName, key: Ids.ResidentKey, generation: number): Ids.ExecutionId;
+    (kind: Ids.ResidentKindName, key: Ids.ResidentKey, generation: number): (tenant: Ids.TenantId) => Ids.ExecutionId;
+};
+export declare const residentAddressId: {
+    (tenant: Ids.TenantId, kind: Ids.ResidentKindName, key: Ids.ResidentKey): Ids.AddressId;
+    (kind: Ids.ResidentKindName, key: Ids.ResidentKey): (tenant: Ids.TenantId) => Ids.AddressId;
+};
+export declare const residentSessionId: {
+    (tenant: Ids.TenantId, kind: Ids.ResidentKindName, key: Ids.ResidentKey): Ids.SessionId;
+    (kind: Ids.ResidentKindName, key: Ids.ResidentKey): (tenant: Ids.TenantId) => Ids.SessionId;
+};
+export declare const layer: Layer.Layer<Service, never, ResidentRepository.Service | AddressBookService | EventLogService | AgentRegistryService | ResidentRegistryService | import("effect/unstable/cluster/Sharding").Sharding>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

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

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