@relayfx/sdk 0.3.7 → 0.4.1

package/dist/types/store-sql/tool/tool-call-repository.d.ts

@@ -1,6 +1,5 @@
 import { Ids, Tool } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const ToolCallRepositoryError_base: Schema.Class<ToolCallRepositoryError, Schema.TaggedStruct<"ToolCallRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -227,7 +226,7 @@ export declare const ToolResultRow: Schema.Struct<{
     readonly metadata_json: Schema.Unknown;
     readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
-export declare const layer: Layer.Layer<Service, never, SqlClient>;
+export declare const layer: Layer.Layer<Service, never, import("effect/unstable/sql/SqlClient").SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 type TestInterface = Pick<Interface, "recordCall" | "getCall" | "listCalls" | "recordResult" | "getResult"> & Partial<Interface>;
 export declare const testLayer: (implementation: TestInterface) => Layer.Layer<Service, never, never>;

package/dist/types/store-sql/tool/tool-work-operations.d.ts

@@ -0,0 +1,11 @@
+import type { ToolAttemptRecordOperations } from "./tool-attempt-records";
+import type { ToolCallRecordSupport, ToolRecordErrors } from "./tool-call-records";
+import type { Interface } from "./tool-call-repository";
+interface MakeToolWorkOperationsInput {
+    readonly records: ToolCallRecordSupport;
+    readonly attempts: ToolAttemptRecordOperations;
+    readonly errors: ToolRecordErrors;
+}
+type ToolWorkOperations = Pick<Interface, "prepareExternalWait" | "beginAttempt" | "acceptClientOutcome" | "claimRemote" | "releaseRemote" | "acceptRemoteOutcome" | "listAttempts" | "failOpenForExecution">;
+export declare const makeToolWorkOperations: ({ records, attempts, errors, }: MakeToolWorkOperationsInput) => ToolWorkOperations;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/sdk",
-  "version": "0.3.7",
+  "version": "0.4.1",
   "description": "Effect-native durable execution SDK for addressable agents and tools",
   "type": "module",
   "exports": {
@@ -57,8 +57,8 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.6.4",
-    "@batonfx/providers": "0.6.4",
+    "@batonfx/core": "0.7.0",
+    "@batonfx/providers": "0.7.0",
     "@effect/ai-anthropic": "4.0.0-beta.98",
     "@effect/ai-openai": "4.0.0-beta.98",
     "@effect/ai-openai-compat": "4.0.0-beta.98",

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 "../../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 "../../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/store-sql/entity/entity-repository.d.ts

@@ -1,36 +0,0 @@
-import { Entity, Ids } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
-declare const EntityRepositoryError_base: Schema.Class<EntityRepositoryError, Schema.TaggedStruct<"EntityRepositoryError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class EntityRepositoryError extends EntityRepositoryError_base {
-}
-export interface CreateInstanceInput {
-    readonly kind: Ids.EntityKindName;
-    readonly key: Ids.EntityKey;
-    readonly addressId: Ids.AddressId;
-    readonly executionId: (generation: number) => Ids.ExecutionId;
-    readonly createdAt: number;
-}
-export interface Interface {
-    readonly putKind: (definition: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, EntityRepositoryError>;
-    readonly getKind: (kind: Ids.EntityKindName) => Effect.Effect<Entity.KindDefinition | undefined, EntityRepositoryError>;
-    readonly listKinds: (_?: never) => Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRepositoryError>;
-    readonly getOrCreate: (input: CreateInstanceInput) => Effect.Effect<Entity.Instance, EntityRepositoryError>;
-    readonly get: (kind: Ids.EntityKindName, key: Ids.EntityKey) => Effect.Effect<Entity.Instance | undefined, EntityRepositoryError>;
-    readonly destroy: (kind: Ids.EntityKindName, key: Ids.EntityKey, destroyedAt: number) => Effect.Effect<Entity.Instance | undefined, EntityRepositoryError>;
-    readonly list: (input: {
-        readonly kind?: Ids.EntityKindName;
-        readonly afterKind?: Ids.EntityKindName;
-        readonly afterKey?: string;
-        readonly limit?: number;
-    }) => Effect.Effect<ReadonlyArray<Entity.Instance>, EntityRepositoryError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/entity/entity-repository/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, SqlClient>;
-export declare const memoryLayer: Layer.Layer<Service, never, never>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export {};