@relayfx/sdk 0.0.27 → 0.0.29

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/database/notification-bus.d.ts

@@ -0,0 +1,16 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+export interface Interface {
+    readonly publish: (channel: string, payload: string) => Effect.Effect<void, SqlError>;
+    readonly subscribe: (channel: string) => Stream.Stream<string, SqlError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/NotificationBus", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const pgLayer: Layer.Layer<Service, never, SqlClient.SqlClient>;
+export declare const inProcessLayer: Layer.Layer<Service, never, never>;
+export declare const mysqlLayer: Layer.Layer<Service, never, never>;
+export declare const layerFromDialect: Layer.Layer<Service, never, SqlClient.SqlClient>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

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

@@ -1,6 +1,7 @@
 import { Execution, Ids } from "../../schema/index";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as NotificationBus from "../database/notification-bus";
 export declare const executionEventsChannel = "relay_execution_events";
 declare const DuplicateExecutionEvent_base: Schema.Class<DuplicateExecutionEvent, Schema.TaggedStruct<"DuplicateExecutionEvent", {
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
@@ -72,7 +73,19 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionEventRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const ExecutionEventRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly child_execution_id: Schema.NullishOr<Schema.String>;
+    readonly type: Schema.String;
+    readonly sequence: Schema.Union<readonly [Schema.Number, Schema.String]>;
+    readonly cursor: Schema.String;
+    readonly content_json: Schema.NullishOr<Schema.Unknown>;
+    readonly data_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 | NotificationBus.Service>;
+export declare const layerWithBus: 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 append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | ExecutionEventRepositoryError, Service>;

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

@@ -1,6 +1,6 @@
 import { 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 IdempotencyRepositoryError_base: Schema.Class<IdempotencyRepositoryError, Schema.TaggedStruct<"IdempotencyRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -34,7 +34,16 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/IdempotencyRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const IdempotencyRow: Schema.Struct<{
+    readonly scope: Schema.String;
+    readonly operation: Schema.String;
+    readonly key: Schema.String;
+    readonly result_json: Schema.NullishOr<Schema.Unknown>;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly expires_at: Schema.NullishOr<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 runOnce: <R>(input: OperationInput, create: Effect.Effect<Shared.JsonValue, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, Service | R>;

package/dist/types/store-sql/index.d.ts

@@ -10,6 +10,7 @@ export * as ExecutionEventRepository from "./execution/execution-event-repositor
 export * as ExecutionRepository from "./execution/execution-repository";
 export * as IdempotencyRepository from "./idempotency/idempotency-repository";
 export * as MemoryRepository from "./memory/memory-repository";
+export * as NotificationBus from "./database/notification-bus";
 export * as PermissionRuleRepository from "./permission/permission-rule-repository";
 export * as ContextEpochRepository from "./session/context-epoch-repository";
 export * as RelaySchema from "./schema/relay-schema";

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

@@ -1,7 +1,7 @@
 import { Ids, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
 import type * as Ai from "effect/unstable/ai";
-import * as Database from "../database/database-service";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
 declare const MemoryRepositoryError_base: Schema.Class<MemoryRepositoryError, Schema.TaggedStruct<"MemoryRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -42,7 +42,17 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/MemoryRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const recallCandidateCap = 1000;
+export declare const MemoryRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly agent: Schema.String;
+    readonly subject: Schema.String;
+    readonly embedding: Schema.Union<readonly [Schema.$Array<Schema.Number>, Schema.String]>;
+    readonly parts_json: Schema.Unknown;
+    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 upsert: (input: UpsertInput) => Effect.Effect<MemoryRecord, MemoryRepositoryError, 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/schedule/schedule-repository.d.ts

@@ -1,6 +1,6 @@
 import { Content, Ids, Schedule, 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 ScheduleRepositoryError_base: Schema.Class<ScheduleRepositoryError, Schema.TaggedStruct<"ScheduleRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -70,7 +70,26 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ScheduleRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const ScheduleRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.String;
+    readonly target_kind: Schema.String;
+    readonly address_id: Schema.NullishOr<Schema.String>;
+    readonly wait_id: Schema.NullishOr<Schema.String>;
+    readonly cron_expr: Schema.NullishOr<Schema.String>;
+    readonly input_json: Schema.NullishOr<Schema.Unknown>;
+    readonly state: Schema.String;
+    readonly next_run_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+    readonly attempt: Schema.Union<readonly [Schema.Number, Schema.String, Schema.BigInt]>;
+    readonly claim_owner: Schema.NullishOr<Schema.String>;
+    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>>;
+    readonly last_error: Schema.NullishOr<Schema.String>;
+    readonly idempotency_key: Schema.NullishOr<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: CreateScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError, 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/skill/skill-definition-repository.d.ts

@@ -1,6 +1,6 @@
 import { Ids, Skill } 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 SkillDefinitionRepositoryError_base: Schema.Class<SkillDefinitionRepositoryError, Schema.TaggedStruct<"SkillDefinitionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -57,7 +57,27 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/SkillDefinitionRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const SkillDefinitionRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly current_revision: Schema.Number;
+    readonly definition_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 SkillDefinitionRevisionRow: Schema.Struct<{
+    readonly skill_definition_id: Schema.String;
+    readonly revision: Schema.Number;
+    readonly definition_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
+}>;
+export declare const ExecutionSkillPinRow: Schema.Struct<{
+    readonly execution_id: Schema.String;
+    readonly skill_definition_id: Schema.String;
+    readonly skill_definition_revision: Schema.Number;
+    readonly skill_definition_snapshot_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: PutSkillDefinitionInput) => Effect.Effect<SkillDefinitionRecord, SkillDefinitionRepositoryError, 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/dist/types/store-sql/workspace/workspace-lease-repository.d.ts

@@ -1,6 +1,6 @@
 import { Ids, Shared, Workspace } 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 WorkspaceLeaseRepositoryError_base: Schema.Class<WorkspaceLeaseRepositoryError, Schema.TaggedStruct<"WorkspaceLeaseRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -73,7 +73,30 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/WorkspaceLeaseRepository", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const WorkspaceLeaseRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly provider_key: Schema.String;
+    readonly sandbox_ref: Schema.NullishOr<Schema.String>;
+    readonly latest_snapshot_ref: Schema.NullishOr<Schema.String>;
+    readonly status: Schema.String;
+    readonly resume_strategy: Schema.String;
+    readonly region: Schema.NullishOr<Schema.String>;
+    readonly request_json: Schema.NullishOr<Schema.Unknown>;
+    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 WorkspaceSnapshotRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly lease_id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly reason: Schema.String;
+    readonly snapshot_ref: 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 plan: (input: PlanInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | DuplicateWorkspaceLease, 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.29",
   "type": "module",
   "exports": {
     ".": {