@relayfx/sdk 0.0.38 → 0.0.40

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

@@ -1,7 +1,7 @@
 import { Envelope, Execution, Ids, Shared } from "../../schema/index";
 import { EnvelopeRepository, ScheduleRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as EventLog from "../execution/event-log-service";
+import { Service as EventLogService } from "../execution/event-log-service";
 declare const WaitNotFound_base: Schema.Class<WaitNotFound, Schema.TaggedStruct<"WaitNotFound", {
     readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
@@ -68,7 +68,7 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WaitService", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | ScheduleRepository.Service | EventLog.Service>;
+export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | ScheduleRepository.Service | EventLogService>;
 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: CreateWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitDefinitionMissing | WaitServiceError, Service>;

package/dist/types/runtime/wait/wait-signal.d.ts

@@ -1,16 +1,16 @@
 import { Ids } from "../../schema/index";
 import { ExecutionRepository } from "../../store-sql/index";
 import { Effect } from "effect";
-import * as ExecutionWorkflow from "../workflow/execution-workflow";
+import type { SignalWaitInput, WaitSignalState } from "../workflow/execution-workflow";
 export interface ExecutionSignalClient {
-    readonly signalWait: (input: ExecutionWorkflow.SignalWaitInput) => Effect.Effect<void, unknown>;
+    readonly signalWait: (input: SignalWaitInput) => Effect.Effect<void, unknown>;
 }
 export type ExecutionClientFactory = (executionId: Ids.ExecutionId) => ExecutionSignalClient;
 export interface SignalWorkflowWaitInput {
     readonly makeExecutionClient: ExecutionClientFactory;
     readonly executionId: Ids.ExecutionId;
     readonly waitId: Ids.WaitId;
-    readonly state: ExecutionWorkflow.WaitSignalState;
+    readonly state: WaitSignalState;
     readonly signaledAt: number;
 }
 export declare const signalWorkflowWait: (input: SignalWorkflowWaitInput) => Effect.Effect<void, unknown, ExecutionRepository.Service>;

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

@@ -2,15 +2,10 @@ import { Ids } from "../../schema/index";
 import { ChildExecutionRepository, ExecutionRepository } from "../../store-sql/index";
 import { Workflow } from "effect/unstable/workflow";
 import { Effect, Layer, Option, Schema } from "effect";
-import * as AddressResolution from "../address/address-resolution-service";
-import * as AgentLoop from "../agent/agent-loop-service";
-import * as ParentNotifier from "../child/parent-notifier-service";
-import * as SkillRegistry from "../skill/skill-registry-service";
-import * as EventLog from "../execution/event-log-service";
-import * as ExecutionService from "../execution/execution-service";
-import * as ToolRuntime from "../tool/tool-runtime-service";
-import * as WaitService from "../wait/wait-service";
-import * as WorkspacePlanner from "../workspace/workspace-planner-service";
+import { Service as AgentLoopService } from "../agent/agent-loop-service";
+import { ChildTerminalStatus } from "../child/parent-notifier-service";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { Service as ToolRuntimeService } from "../tool/tool-runtime-service";
 declare const ExecutionWorkflowFailed_base: Schema.Class<ExecutionWorkflowFailed, Schema.TaggedStruct<"ExecutionWorkflowFailed", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -78,11 +73,11 @@ export declare const StartInput: Schema.Struct<{
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
-    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+    readonly agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -137,7 +132,7 @@ export declare const StartInput: Schema.Struct<{
         readonly output_schema_ref: Schema.optionalKey<Schema.String>;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>>;
-    readonly agent_definition_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
@@ -239,7 +234,7 @@ export declare const ActivityNames: {
     readonly releaseWorkspace: "Relay/Execution/Start/ReleaseWorkspace";
     readonly complete: (turn: number) => string;
     readonly checkQueuedChildCancellation: "Relay/Execution/Start/CheckQueuedChildCancellation";
-    readonly notifyParent: (status: ParentNotifier.ChildTerminalStatus) => string;
+    readonly notifyParent: (status: ChildTerminalStatus) => string;
     readonly continueAsNew: (turn: number) => string;
 };
 export declare const ActivityNameTemplates: {
@@ -321,11 +316,11 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     readonly event_sequence: Schema.Int;
     readonly started_at: Schema.Int;
     readonly completed_at: Schema.Int;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
-    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+    readonly agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -380,7 +375,7 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
         readonly output_schema_ref: Schema.optionalKey<Schema.String>;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>>;
-    readonly agent_definition_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     readonly wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
     }>;
@@ -406,7 +401,7 @@ export declare const StartExecutionWorkflow: Workflow.Workflow<"Relay/Execution/
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>, typeof ExecutionWorkflowFailed>;
 export declare const sessionEntryScope: (input: StartInput, turn: number) => string;
-export declare const layer: Layer.Layer<never, never, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLog.Service | WaitService.Service | ToolRuntime.Service | AddressResolution.Service | AgentLoop.Service | SkillRegistry.Service | ExecutionService.Service | WorkspacePlanner.Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+export declare const layer: Layer.Layer<never, never, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLogService | import("../wait/wait-service").Service | ToolRuntimeService | import("../address/address-resolution-service").Service | AgentLoopService | import("../skill/skill-registry-service").Service | import("../execution/execution-service").Service | import("../workspace/workspace-planner-service").Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
 export declare const start: <const Discard extends boolean = false>(input: StartInput, options?: {
     readonly discard?: Discard;
 }) => Effect.Effect<Discard extends true ? string : {
@@ -430,7 +425,7 @@ export declare const startRequest: (input: StartInput) => Effect.Effect<{
 export declare const cancelRequest: (input: CancelExecutionInput) => Effect.Effect<{
     execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     status: "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled";
-}, ExecutionWorkflowFailed, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLog.Service | WaitService.Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
+}, ExecutionWorkflowFailed, ChildExecutionRepository.Service | ExecutionRepository.Service | EventLogService | import("../wait/wait-service").Service | import("effect/unstable/workflow/WorkflowEngine").WorkflowEngine>;
 export declare const poll: (executionId: string) => Effect.Effect<Option.Option<Workflow.Result<{
     readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
     readonly status: "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled";

package/dist/types/runtime/workspace/workspace-planner-service.d.ts

@@ -1,9 +1,10 @@
 import { Agent, Ids, Shared, Tool, Workspace } from "../../schema/index";
 import { WorkspaceLeaseRepository } from "../../store-sql/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as EventLog from "../execution/event-log-service";
-import * as WorkspaceProvider from "./workspace-provider-service";
-import * as WorkspaceRuntime from "./workspace-runtime-service";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { WorkspaceCapabilityUnsupported } from "./workspace-provider-service";
+import type { WorkspaceNotFound, WorkspaceProviderError, WorkspaceUnavailable } from "./workspace-provider-service";
+import { Service as WorkspaceRuntimeService } from "./workspace-runtime-service";
 declare const WorkspaceRuntimeMissing_base: Schema.Class<WorkspaceRuntimeMissing, Schema.TaggedStruct<"WorkspaceRuntimeMissing", {
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
@@ -32,7 +33,7 @@ export interface EnsureInput {
 }
 export interface WorkspacePlan {
     readonly lease: Workspace.WorkspaceLeaseRecord;
-    readonly runtimeLayer: Layer.Layer<WorkspaceRuntime.Service>;
+    readonly runtimeLayer: Layer.Layer<WorkspaceRuntimeService>;
 }
 export interface LifecycleInput {
     readonly executionId: Ids.ExecutionId;
@@ -42,22 +43,22 @@ export interface FailureInput extends LifecycleInput {
     readonly metadata?: Shared.Metadata;
 }
 export interface Interface {
-    readonly ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError>;
-    readonly suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceCapabilityUnsupported | WorkspaceProvider.WorkspaceProviderError>;
-    readonly resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError>;
-    readonly attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError>;
-    readonly release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProvider.WorkspaceProviderError>;
+    readonly ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
+    readonly suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError>;
+    readonly resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
+    readonly attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError>;
+    readonly release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError | WorkspaceProviderError>;
     readonly fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspacePlanner", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layer: Layer.Layer<Service, never, WorkspaceLeaseRepository.Service | EventLog.Service>;
+export declare const layer: Layer.Layer<Service, never, WorkspaceLeaseRepository.Service | EventLogService>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceCapabilityUnsupported | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceProvider.WorkspaceNotFound | WorkspaceProvider.WorkspaceUnavailable | WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
-export declare const release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceProvider.WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const ensure: (input: EnsureInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const suspend: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceNotFound | WorkspaceCapabilityUnsupported | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const resume: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const attach: (input: LifecycleInput) => Effect.Effect<WorkspacePlan | undefined, WorkspaceNotFound | WorkspaceUnavailable | WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
+export declare const release: (input: LifecycleInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceProviderError | WorkspaceRuntimeMissing | WorkspaceLeaseMissingRef | WorkspacePlannerError, Service>;
 export declare const fail: (input: FailureInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspacePlannerError, Service>;
 export {};

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

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer, Schema } from "effect";
-import * as WorkspaceProvider from "./workspace-provider-service";
+import type { WorkspaceCommandInput, WorkspaceCommandResult, WorkspaceHandle } from "./workspace-provider-service";
 declare const WorkspaceRuntimeError_base: Schema.Class<WorkspaceRuntimeError, Schema.TaggedStruct<"WorkspaceRuntimeError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -8,14 +8,14 @@ export declare class WorkspaceRuntimeError extends WorkspaceRuntimeError_base {
 export interface Interface {
     readonly readFile: (path: string) => Effect.Effect<string, WorkspaceRuntimeError>;
     readonly writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceRuntimeError>;
-    readonly exec: (input: WorkspaceProvider.WorkspaceCommandInput) => Effect.Effect<WorkspaceProvider.WorkspaceCommandResult, WorkspaceRuntimeError>;
+    readonly exec: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceRuntimeError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/WorkspaceRuntime", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const layerFromHandle: (handle: WorkspaceProvider.WorkspaceHandle) => Layer.Layer<Service, never, never>;
+export declare const layerFromHandle: (handle: WorkspaceHandle) => Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const readFile: (path: string) => Effect.Effect<string, WorkspaceRuntimeError, Service>;
 export declare const writeFile: (path: string, content: string) => Effect.Effect<void, WorkspaceRuntimeError, Service>;
-export declare const exec: (input: WorkspaceProvider.WorkspaceCommandInput) => Effect.Effect<WorkspaceProvider.WorkspaceCommandResult, WorkspaceRuntimeError, Service>;
+export declare const exec: (input: WorkspaceCommandInput) => Effect.Effect<WorkspaceCommandResult, WorkspaceRuntimeError, Service>;
 export {};

package/dist/types/schema/agent-schema.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { AgentDefinitionId, SkillDefinitionId } from "./ids-schema";
+import { AgentId, SkillDefinitionId } from "./ids-schema";
 import { Metadata, NonEmptyString } from "./shared-schema";
 import { Permission } from "./tool-schema";
 export declare const DefinitionRevision: Schema.Int;
@@ -67,15 +67,7 @@ export interface PermissionRuleset extends Schema.Schema.Type<typeof PermissionR
 export declare const ToolInputSchemaDigests: Schema.$Record<Schema.String, Schema.String>;
 export interface ToolInputSchemaDigests extends Schema.Schema.Type<typeof ToolInputSchemaDigests> {
 }
-/**
- * Default per-`AgentLoop.run` tool-turn budget when `max_tool_turns` is absent.
- * Preserves pre-configuration behavior bit-for-bit.
- */
 export declare const defaultMaxToolTurns = 8;
-/**
- * Default per-execution wait-turn budget when `max_wait_turns` is absent.
- * Preserves pre-configuration behavior bit-for-bit.
- */
 export declare const defaultMaxWaitTurns = 8;
 export declare const Definition: Schema.Struct<{
     readonly name: Schema.String;
@@ -140,7 +132,7 @@ export type ToolRef = {
     readonly name: string;
 } & Readonly<Record<string, unknown>>);
 export interface DefineInput {
-    readonly id: AgentDefinitionId;
+    readonly id: AgentId;
     readonly name: NonEmptyString;
     readonly instructions?: string;
     readonly model: ModelSelection;
@@ -158,8 +150,8 @@ export interface DefineInput {
 }
 export declare const define: (input: DefineInput) => RegisterDefinitionPayload;
 export declare const DefinitionRecord: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     };
     readonly current_revision: Schema.Int;
     readonly definition: Schema.Struct<{
@@ -224,8 +216,8 @@ export declare const DefinitionRecord: Schema.Struct<{
 export interface DefinitionRecord extends Schema.Schema.Type<typeof DefinitionRecord> {
 }
 export declare const DefinitionRevisionRecord: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     };
     readonly revision: Schema.Int;
     readonly definition: Schema.Struct<{
@@ -289,8 +281,8 @@ export declare const DefinitionRevisionRecord: Schema.Struct<{
 export interface DefinitionRevisionRecord extends Schema.Schema.Type<typeof DefinitionRevisionRecord> {
 }
 export declare const RegisterDefinitionPayload: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     };
     readonly definition: Schema.Struct<{
         readonly name: Schema.String;
@@ -352,8 +344,8 @@ export interface RegisterDefinitionPayload extends Schema.Schema.Type<typeof Reg
 }
 export declare const DefinitionRegistered: Schema.Struct<{
     readonly record: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
         };
         readonly current_revision: Schema.Int;
         readonly definition: Schema.Struct<{
@@ -420,8 +412,8 @@ export interface DefinitionRegistered extends Schema.Schema.Type<typeof Definiti
 }
 export declare const DefinitionList: Schema.Struct<{
     readonly records: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
         };
         readonly current_revision: Schema.Int;
         readonly definition: Schema.Struct<{
@@ -488,8 +480,8 @@ export interface DefinitionList extends Schema.Schema.Type<typeof DefinitionList
 }
 export declare const DefinitionRevisionList: Schema.Struct<{
     readonly records: Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+        readonly id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
         };
         readonly revision: Schema.Int;
         readonly definition: Schema.Struct<{

package/dist/types/schema/execution-schema.d.ts

@@ -12,11 +12,11 @@ export declare const Execution: Schema.Struct<{
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SessionId">;
     }>;
     readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-    readonly agent_definition_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    readonly agent_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
     }>;
-    readonly agent_definition_revision: Schema.optionalKey<Schema.Int>;
-    readonly agent_definition_snapshot: Schema.optionalKey<Schema.Struct<{
+    readonly agent_revision: Schema.optionalKey<Schema.Int>;
+    readonly agent_snapshot: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
         readonly instructions: Schema.optionalKey<Schema.String>;
         readonly model: Schema.Struct<{
@@ -71,7 +71,7 @@ export declare const Execution: Schema.Struct<{
         readonly output_schema_ref: Schema.optionalKey<Schema.String>;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>>;
-    readonly agent_definition_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly agent_tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     readonly created_at: Schema.Int;
     readonly updated_at: Schema.Int;

package/dist/types/schema/ids-schema.d.ts

@@ -12,10 +12,10 @@ export declare const AddressBookEntryId: Schema.brand<Schema.String, "Relay.Addr
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
 };
 export type AddressBookEntryId = typeof AddressBookEntryId.Type;
-export declare const AgentDefinitionId: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
-    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+export declare const AgentId: Schema.brand<Schema.String, "Relay.AgentId"> & {
+    make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
 };
-export type AgentDefinitionId = typeof AgentDefinitionId.Type;
+export type AgentId = typeof AgentId.Type;
 export declare const SkillDefinitionId: Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
     make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
 };

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 SqlClient from "effect/unstable/sql/SqlClient";
+import { 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", {
@@ -48,7 +48,7 @@ export declare const AddressBookRow: Schema.Struct<{
     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 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 declare const upsert: (input: UpsertAddressBookEntryInput) => Effect.Effect<AddressBookEntry, AddressBookRepositoryError, Service>;

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

@@ -1,13 +1,13 @@
 import { Agent, Ids } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const AgentDefinitionRepositoryError_base: Schema.Class<AgentDefinitionRepositoryError, Schema.TaggedStruct<"AgentDefinitionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class AgentDefinitionRepositoryError extends AgentDefinitionRepositoryError_base {
 }
 export interface AgentDefinitionRecord {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly currentRevision: Agent.DefinitionRevision;
     readonly definition: Agent.Definition;
     readonly toolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
@@ -15,28 +15,28 @@ export interface AgentDefinitionRecord {
     readonly updatedAt: number;
 }
 export interface AgentDefinitionRevisionRecord {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly revision: Agent.DefinitionRevision;
     readonly definition: Agent.Definition;
     readonly toolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly createdAt: number;
 }
 export interface PutAgentDefinitionInput {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly definition: Agent.Definition;
     readonly toolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly now: number;
 }
 export interface GetAgentDefinitionRevisionInput {
-    readonly id: Ids.AgentDefinitionId;
+    readonly id: Ids.AgentId;
     readonly revision: Agent.DefinitionRevision;
 }
 export interface Interface {
     readonly put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError>;
-    readonly get: (id: Ids.AgentDefinitionId) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError>;
+    readonly get: (id: Ids.AgentId) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError>;
     readonly getRevision: (input: GetAgentDefinitionRevisionInput) => Effect.Effect<AgentDefinitionRevisionRecord | undefined, AgentDefinitionRepositoryError>;
     readonly list: () => Effect.Effect<ReadonlyArray<AgentDefinitionRecord>, AgentDefinitionRepositoryError>;
-    readonly listRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<ReadonlyArray<AgentDefinitionRevisionRecord>, AgentDefinitionRepositoryError>;
+    readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<ReadonlyArray<AgentDefinitionRevisionRecord>, AgentDefinitionRepositoryError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/AgentDefinitionRepository", Interface>;
 export declare class Service extends Service_base {
@@ -50,18 +50,18 @@ export declare const AgentDefinitionRow: Schema.Struct<{
     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 agent_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 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 declare const put: (input: PutAgentDefinitionInput) => Effect.Effect<AgentDefinitionRecord, AgentDefinitionRepositoryError, Service>;
-export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<AgentDefinitionRecord | undefined, AgentDefinitionRepositoryError, Service>;
 export declare const getRevision: (input: GetAgentDefinitionRevisionInput) => Effect.Effect<AgentDefinitionRevisionRecord | undefined, AgentDefinitionRepositoryError, Service>;
 export declare const list: () => Effect.Effect<readonly AgentDefinitionRecord[], AgentDefinitionRepositoryError, Service>;
-export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<readonly AgentDefinitionRevisionRecord[], AgentDefinitionRepositoryError, Service>;
+export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<readonly AgentDefinitionRevisionRecord[], AgentDefinitionRepositoryError, Service>;
 export {};

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

@@ -1,6 +1,6 @@
 import { Ids } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const AgentChatRepositoryError_base: Schema.Class<AgentChatRepositoryError, Schema.TaggedStruct<"AgentChatRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -28,7 +28,7 @@ export declare const AgentChatRow: Schema.Struct<{
     readonly export_json: Schema.Unknown;
     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 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 declare const save: (input: SaveInput) => Effect.Effect<AgentChatRecord, AgentChatRepositoryError, 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 SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const ChildExecutionRepositoryError_base: Schema.Class<ChildExecutionRepositoryError, Schema.TaggedStruct<"ChildExecutionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -61,7 +61,7 @@ export declare const ChildExecutionRow: Schema.Struct<{
     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 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 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 * as SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const ClusterRegistryError_base: Schema.Class<ClusterRegistryError, Schema.TaggedStruct<"ClusterRegistryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -27,7 +27,7 @@ export declare const RunnerRow: Schema.Struct<{
 export declare const LockRow: Schema.Struct<{
     readonly address: Schema.String;
 }>;
-export declare const layer: Layer.Layer<Service, never, SqlClient.SqlClient>;
+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 declare const listRunners: () => Effect.Effect<readonly RunnerRecord[], ClusterRegistryError, Service>;

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 SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const CompactionRepositoryError_base: Schema.Class<CompactionRepositoryError, Schema.TaggedStruct<"CompactionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -36,7 +36,7 @@ export declare const CompactionCheckpointRow: Schema.Struct<{
     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 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 declare const get: (input: GetInput) => Effect.Effect<CompactionCheckpointRecord | undefined, CompactionRepositoryError, Service>;

package/dist/types/store-sql/database/database-service.d.ts

@@ -1,12 +1,11 @@
-import * as MysqlClient from "@effect/sql-mysql2/MysqlClient";
-import * as PgClient from "@effect/sql-pg/PgClient";
-import * as PgDrizzle from "drizzle-orm/effect-postgres";
+import { PgClient } from "@effect/sql-pg/PgClient";
+import { EffectPgDatabase } from "drizzle-orm/effect-postgres";
 import type { EffectDrizzleQueryError } from "drizzle-orm/effect-core/errors";
 import { Config, Context, Effect, Layer, Schema } from "effect";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 import type { SqlError } from "effect/unstable/sql/SqlError";
-export type Drizzle = PgDrizzle.EffectPgDatabase & {
-    readonly $client: PgClient.PgClient;
+export type Drizzle = EffectPgDatabase & {
+    readonly $client: PgClient;
 };
 export type PgTimestamp = Date | string | number;
 export type DatabaseError = EffectDrizzleQueryError | SqlError;
@@ -19,17 +18,17 @@ export declare const fromNullablePgDate: (timestamp: PgTimestamp | null | undefi
 export declare const pgTypeParsers: {
     getTypeParser: (typeId: number, format?: "text" | "binary") => any;
 };
-export declare const PgClientLive: Layer.Layer<PgClient.PgClient | SqlClient.SqlClient, SqlError | Config.ConfigError, never>;
-export declare const layerFromPgClient: Layer.Layer<Service, never, PgClient.PgClient>;
+export declare const PgClientLive: Layer.Layer<PgClient | SqlClient, SqlError | Config.ConfigError, never>;
+export declare const layerFromPgClient: Layer.Layer<Service, never, PgClient>;
 export declare const layer: Layer.Layer<Service, SqlError | Config.ConfigError, never>;
 export declare const testLayer: (db: Drizzle) => Layer.Layer<Service, never, never>;
 export declare const check: () => Effect.Effect<void, EffectDrizzleQueryError, Service>;
 export declare const Dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
 export type Dialect = typeof Dialect.Type;
-export declare const dialect: Effect.Effect<Dialect, never, SqlClient.SqlClient>;
-export declare const MysqlClientLive: Layer.Layer<SqlClient.SqlClient | MysqlClient.MysqlClient, SqlError | Config.ConfigError, never>;
-export declare const SqliteClientLive: Layer.Layer<SqlClient.SqlClient | import("@effect/sql-sqlite-bun/SqliteClient").SqliteClient, Config.ConfigError, never>;
-export declare const timestampParam: (client: SqlClient.SqlClient, millis: number) => Date | number;
+export declare const dialect: Effect.Effect<Dialect, never, SqlClient>;
+export declare const MysqlClientLive: Layer.Layer<SqlClient | import("@effect/sql-mysql2/MysqlClient").MysqlClient, SqlError | Config.ConfigError, never>;
+export declare const SqliteClientLive: Layer.Layer<SqlClient | import("@effect/sql-sqlite-bun/SqliteClient").SqliteClient, Config.ConfigError, never>;
+export declare const timestampParam: (client: SqlClient, millis: number) => Date | number;
 export declare const fromDbTimestamp: (timestamp: PgTimestamp) => number;
 export declare const fromNullableDbTimestamp: (timestamp: PgTimestamp | null | undefined) => number | undefined;
 export declare const encodeJson: (value: unknown) => string;

package/dist/types/store-sql/database/notification-bus.d.ts

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer, Stream } from "effect";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
+import { 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>;
@@ -8,9 +8,9 @@ export interface Interface {
 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 pgLayer: Layer.Layer<Service, never, 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 layerFromDialect: Layer.Layer<Service, never, SqlClient>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export {};