@relayfx/sdk 0.0.27 → 0.0.28

package/dist/types/store-sql/address/address-book-repository.d.ts

@@ -1,6 +1,6 @@
 import { Ids, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 export declare const RouteKind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
 export type RouteKind = typeof RouteKind.Type;
 declare const AddressNotFound_base: Schema.Class<AddressNotFound, Schema.TaggedStruct<"AddressNotFound", {
@@ -39,7 +39,16 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AddressBookRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const AddressBookRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly address_id: Schema.String;
+    readonly route_kind: Schema.String;
+    readonly route_key: Schema.String;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const upsert: (input: UpsertAddressBookEntryInput) => Effect.Effect<AddressBookEntry, AddressBookRepositoryError, Service>;

package/dist/types/store-sql/agent/agent-definition-repository.d.ts

@@ -1,6 +1,6 @@
 import { Agent, Ids } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const AgentDefinitionRepositoryError_base: Schema.Class<AgentDefinitionRepositoryError, Schema.TaggedStruct<"AgentDefinitionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -41,7 +41,22 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AgentDefinitionRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const AgentDefinitionRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly current_revision: Schema.Number;
+    readonly definition_json: Schema.Unknown;
+    readonly tool_input_schema_digests_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const AgentDefinitionRevisionRow: Schema.Struct<{
+    readonly agent_definition_id: Schema.String;
+    readonly revision: Schema.Number;
+    readonly definition_json: Schema.Unknown;
+    readonly tool_input_schema_digests_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError, Service>;

package/dist/types/store-sql/child/child-execution-repository.d.ts

@@ -1,6 +1,6 @@
 import { Execution, Ids, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const ChildExecutionRepositoryError_base: Schema.Class<ChildExecutionRepositoryError, Schema.TaggedStruct<"ChildExecutionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -52,7 +52,16 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ChildExecutionRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const ChildExecutionRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly address_id: Schema.String;
+    readonly status: Schema.String;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const create: (input: CreateChildExecutionInput) => Effect.Effect<ChildExecutionRecord, ChildExecutionRepositoryError | DuplicateChildExecution, Service>;

package/dist/types/store-sql/cluster/cluster-registry-repository.d.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer, Schema } from "effect";
-import { SqlClient } from "effect/unstable/sql";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const ClusterRegistryError_base: Schema.Class<ClusterRegistryError, Schema.TaggedStruct<"ClusterRegistryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -20,9 +20,9 @@ export declare class Service extends Service_base {
 }
 export declare const RunnerRow: Schema.Struct<{
     readonly address: Schema.String;
-    readonly healthy: Schema.Boolean;
-    readonly last_heartbeat: Schema.Union<readonly [Schema.Date, Schema.DateFromString]>;
-    readonly owned_shards: Schema.Union<readonly [Schema.Number, Schema.NumberFromString]>;
+    readonly healthy: Schema.Union<readonly [Schema.Boolean, Schema.Number, Schema.String]>;
+    readonly last_heartbeat: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly owned_shards: Schema.Union<readonly [Schema.Number, Schema.String, Schema.BigInt]>;
 }>;
 export declare const LockRow: Schema.Struct<{
     readonly address: Schema.String;

package/dist/types/store-sql/compaction/compaction-repository.d.ts

@@ -1,6 +1,6 @@
 import { Ids } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const CompactionRepositoryError_base: Schema.Class<CompactionRepositoryError, Schema.TaggedStruct<"CompactionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -28,7 +28,15 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/CompactionRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const CompactionCheckpointRow: Schema.Struct<{
+    readonly execution_id: Schema.String;
+    readonly checkpoint_id: Schema.String;
+    readonly summary: Schema.String;
+    readonly first_kept_entry_id: Schema.String;
+    readonly turn: Schema.Number;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const get: (input: GetInput) => Effect.Effect<CompactionCheckpointRecord | undefined, CompactionRepositoryError, Service>;

package/dist/types/store-sql/permission/permission-rule-repository.d.ts

@@ -1,6 +1,6 @@
-import { Agent } from "../../schema/index";
+import type { Agent } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const PermissionRuleRepositoryError_base: Schema.Class<PermissionRuleRepositoryError, Schema.TaggedStruct<"PermissionRuleRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -29,7 +29,13 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/PermissionRuleRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const PermissionRuleRow: Schema.Struct<{
+    readonly agent: Schema.String;
+    readonly scope: Schema.String;
+    readonly rule_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const remember: (input: RememberInput) => Effect.Effect<PermissionRuleRecord, PermissionRuleRepositoryError, Service>;

package/dist/types/store-sql/session/context-epoch-repository.d.ts

@@ -1,6 +1,6 @@
 import { Ids } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const ContextEpochRepositoryError_base: Schema.Class<ContextEpochRepositoryError, Schema.TaggedStruct<"ContextEpochRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -25,7 +25,13 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ContextEpochRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const ContextEpochRow: Schema.Struct<{
+    readonly execution_id: Schema.String;
+    readonly baseline: Schema.String;
+    readonly dynamic_source_ids_json: Schema.Unknown;
+    readonly opened_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const save: (input: SaveInput) => Effect.Effect<ContextEpochRecord, ContextEpochRepositoryError, Service>;

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

@@ -1,6 +1,6 @@
 import { Ids, Tool } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const ToolCallRepositoryError_base: Schema.Class<ToolCallRepositoryError, Schema.TaggedStruct<"ToolCallRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -55,7 +55,22 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ToolCallRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const ToolCallRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly name: Schema.String;
+    readonly input_json: Schema.Unknown;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const ToolResultRow: Schema.Struct<{
+    readonly tool_call_id: Schema.String;
+    readonly output_json: Schema.Unknown;
+    readonly error: Schema.NullishOr<Schema.String>;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const recordCall: (input: RecordCallInput) => Effect.Effect<ToolCallRecord, ToolCallRepositoryError | DuplicateToolCall, Service>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/sdk",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "type": "module",
   "exports": {
     ".": {