@relayfx/sdk 0.0.39 → 0.0.40

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.AgentId"> & {
+    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.AgentId"> & {
+    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

@@ -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;

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.AgentId"> & {
+    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/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,6 +1,6 @@
 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>;
@@ -50,13 +50,13 @@ 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>;

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 {};

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

@@ -1,6 +1,6 @@
 import { Address, Envelope, 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 WaitState: Schema.Literals<readonly ["open", "resolved", "timed_out", "cancelled"]>;
 export type WaitState = typeof WaitState.Type;
 export declare const EnvelopeReadyState: Schema.Literals<readonly ["ready", "claimed", "acknowledged"]>;
@@ -182,7 +182,7 @@ export declare const EnvelopeReadyRow: Schema.Struct<{
     readonly claimed_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number, Schema.Null]>;
     readonly acknowledged_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number, Schema.Null]>;
 }>;
-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 acceptEnvelope: (input: AcceptEnvelopeInput) => Effect.Effect<Envelope.EnvelopeAccepted, EnvelopeRepositoryError, Service>;

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

@@ -1,7 +1,7 @@
 import { Execution, Ids } from "../../schema/index";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
-import * as NotificationBus from "../database/notification-bus";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Service as NotificationBusService } 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"> & {
@@ -84,8 +84,8 @@ export declare const ExecutionEventRow: Schema.Struct<{
     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 layer: Layer.Layer<Service, never, SqlClient | NotificationBusService>;
+export declare const layerWithBus: 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 append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | ExecutionEventRepositoryError, Service>;

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

@@ -1,6 +1,6 @@
 import { Agent, 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 ExecutionRepositoryError_base: Schema.Class<ExecutionRepositoryError, Schema.TaggedStruct<"ExecutionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -26,9 +26,9 @@ export interface ExecutionRecord {
     readonly sessionId?: Ids.SessionId;
     readonly status: Execution.ExecutionStatus;
     readonly agentId?: Ids.AgentId;
-    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
-    readonly agentDefinitionSnapshot?: Agent.Definition;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly agentRevision?: Agent.DefinitionRevision;
+    readonly agentSnapshot?: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly metadata: Shared.Metadata;
     readonly createdAt: number;
     readonly updatedAt: number;
@@ -39,9 +39,9 @@ export interface CreateExecutionInput {
     readonly sessionId?: Ids.SessionId;
     readonly status: Execution.ExecutionStatus;
     readonly agentId?: Ids.AgentId;
-    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
-    readonly agentDefinitionSnapshot?: Agent.Definition;
-    readonly agentDefinitionToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly agentRevision?: Agent.DefinitionRevision;
+    readonly agentSnapshot?: Agent.Definition;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
     readonly metadata?: Shared.Metadata;
     readonly createdAt: number;
 }
@@ -80,15 +80,15 @@ export declare const ExecutionRow: Schema.Struct<{
     readonly root_address_id: Schema.String;
     readonly session_id: Schema.NullishOr<Schema.String>;
     readonly status: Schema.String;
-    readonly agent_definition_id: Schema.NullishOr<Schema.String>;
-    readonly agent_definition_revision: Schema.NullishOr<Schema.Number>;
-    readonly agent_definition_snapshot_json: Schema.NullishOr<Schema.Unknown>;
-    readonly agent_definition_tool_input_schema_digests_json: Schema.Unknown;
+    readonly agent_id: Schema.NullishOr<Schema.String>;
+    readonly agent_revision: Schema.NullishOr<Schema.Number>;
+    readonly agent_snapshot_json: Schema.NullishOr<Schema.Unknown>;
+    readonly agent_tool_input_schema_digests_json: 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 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: CreateExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionRepositoryError | DuplicateExecution, 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 SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const IdempotencyRepositoryError_base: Schema.Class<IdempotencyRepositoryError, Schema.TaggedStruct<"IdempotencyRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -43,9 +43,9 @@ export declare const IdempotencyRow: Schema.Struct<{
     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 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 runOnce: <R>(input: OperationInput, create: Effect.Effect<Shared.JsonValue, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, Service | R>;
+export declare const runOnce: <R>(input: OperationInput, create: Effect.Effect<Schema.Json, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, Service | R>;
 export declare const transaction: <A, R>(effect: Effect.Effect<A, IdempotencyRepositoryError, R>) => Effect.Effect<A, IdempotencyRepositoryError, Service | R>;
 export {};

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 SqlClient from "effect/unstable/sql/SqlClient";
+import type { Part } from "effect/unstable/ai/Prompt";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const MemoryRepositoryError_base: Schema.Class<MemoryRepositoryError, Schema.TaggedStruct<"MemoryRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -12,7 +12,7 @@ export interface MemoryRecord {
     readonly agent: string;
     readonly subject: Ids.MemorySubjectId;
     readonly embedding: ReadonlyArray<number>;
-    readonly parts: ReadonlyArray<Ai.Prompt.Part>;
+    readonly parts: ReadonlyArray<Part>;
     readonly metadata: Shared.Metadata;
     readonly createdAt: number;
 }
@@ -25,7 +25,7 @@ export interface UpsertInput {
     readonly agent: string;
     readonly subject: Ids.MemorySubjectId;
     readonly embedding: ReadonlyArray<number>;
-    readonly parts: ReadonlyArray<Ai.Prompt.Part>;
+    readonly parts: ReadonlyArray<Part>;
     readonly metadata?: Shared.Metadata | undefined;
     readonly createdAt: number;
 }
@@ -52,7 +52,7 @@ export declare const MemoryRow: Schema.Struct<{
     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 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: UpsertInput) => Effect.Effect<MemoryRecord, MemoryRepositoryError, Service>;

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

@@ -1,6 +1,6 @@
 import type { Agent } 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 PermissionRuleRepositoryError_base: Schema.Class<PermissionRuleRepositoryError, Schema.TaggedStruct<"PermissionRuleRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -35,7 +35,7 @@ export declare const PermissionRuleRow: Schema.Struct<{
     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 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 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 SqlClient from "effect/unstable/sql/SqlClient";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const ScheduleRepositoryError_base: Schema.Class<ScheduleRepositoryError, Schema.TaggedStruct<"ScheduleRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -89,7 +89,7 @@ export declare const ScheduleRow: 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: CreateScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError, Service>;