@relayfx/sdk 0.2.14 → 0.2.16

package/dist/{index-qg0hy7s1.js → index-per7tyzq.js}

@@ -2,7 +2,7 @@
 import {
   __export,
   exports_model_registry
-} from "./index-9q3yh32k.js";
+} from "./index-5x686v8w.js";
 
 // ../ai/src/language-model/language-model-registration.ts
 var exports_language_model_registration = {};
@@ -24,7 +24,7 @@ __export(exports_language_model_registration, {
   anthropic: () => anthropic
 });
 
-// ../../node_modules/.bun/@batonfx+providers@0.4.3/node_modules/@batonfx/providers/dist/anthropic.js
+// ../../node_modules/.bun/@batonfx+providers@0.4.4/node_modules/@batonfx/providers/dist/anthropic.js
 import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
 import { Config, Layer, Redacted } from "effect";
 import { FetchHttpClient } from "effect/unstable/http";
@@ -40,13 +40,13 @@ var anthropic = (input) => exports_model_registry.registrationFromLayer({
 });
 var anthropicClientLayerConfig = AnthropicClient.layerConfig;
 var withAnthropic = (options) => exports_model_registry.layerFromRegistrationEffects([anthropic(options)]).pipe(Layer.provide(AnthropicClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer.provide(FetchHttpClient.layer));
-// ../../node_modules/.bun/@batonfx+providers@0.4.3/node_modules/@batonfx/providers/dist/deterministic.js
+// ../../node_modules/.bun/@batonfx+providers@0.4.4/node_modules/@batonfx/providers/dist/deterministic.js
 import { OpenAiClient as OpenAiClient2 } from "@effect/ai-openai";
 import { Effect, Layer as Layer3, Option, Stream } from "effect";
 import { LanguageModel, Response } from "effect/unstable/ai";
 import { FetchHttpClient as FetchHttpClient3 } from "effect/unstable/http";
 
-// ../../node_modules/.bun/@batonfx+providers@0.4.3/node_modules/@batonfx/providers/dist/openai.js
+// ../../node_modules/.bun/@batonfx+providers@0.4.4/node_modules/@batonfx/providers/dist/openai.js
 import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
 import { Config as Config2, Layer as Layer2, Redacted as Redacted2 } from "effect";
 import { FetchHttpClient as FetchHttpClient2 } from "effect/unstable/http";
@@ -63,7 +63,7 @@ var openAi = (input) => exports_model_registry.registrationFromLayer({
 var openAiClientLayerConfig = OpenAiClient.layerConfig;
 var withOpenAi = (options) => exports_model_registry.layerFromRegistrationEffects([openAi(options)]).pipe(Layer2.provide(OpenAiClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Layer2.provide(FetchHttpClient2.layer));
 
-// ../../node_modules/.bun/@batonfx+providers@0.4.3/node_modules/@batonfx/providers/dist/deterministic.js
+// ../../node_modules/.bun/@batonfx+providers@0.4.4/node_modules/@batonfx/providers/dist/deterministic.js
 var deterministicModelLayer = Layer3.effect(LanguageModel.LanguageModel, LanguageModel.make({
   generateText: () => Effect.succeed([{ type: "text", text: "deterministic response" }]),
   streamText: () => Stream.make(Response.makePart("text-delta", { id: "text", delta: "deterministic response" }))
@@ -81,13 +81,17 @@ var withOpenAiOrDeterministic = (options) => Layer3.unwrap(Effect.gen(function*
     provider: options.fallbackProvider ?? "deterministic",
     model: options.fallbackModel
   });
-  const openAiRegistration = yield* openAi(options).pipe(Effect.provide(OpenAiClient2.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })), Effect.provide(FetchHttpClient3.layer), Effect.asSome, Effect.catchTag("ConfigError", () => Effect.succeedNone));
+  const providerLayer = OpenAiClient2.layerConfig({
+    ...options.clientConfig,
+    apiKey: options.apiKey
+  }).pipe(Layer3.provide(FetchHttpClient3.layer));
+  const openAiRegistration = yield* Effect.scoped(Layer3.build(providerLayer).pipe(Effect.flatMap((context) => openAi(options).pipe(Effect.provide(context))), Effect.asSome, Effect.catchTag("ConfigError", () => Effect.succeedNone)));
   return exports_model_registry.layer([
     deterministic,
     ...Option.isSome(openAiRegistration) ? [openAiRegistration.value] : []
   ]);
 }));
-// ../../node_modules/.bun/@batonfx+providers@0.4.3/node_modules/@batonfx/providers/dist/openai-compat.js
+// ../../node_modules/.bun/@batonfx+providers@0.4.4/node_modules/@batonfx/providers/dist/openai-compat.js
 import { OpenAiClient as OpenAiClient3, OpenAiLanguageModel as OpenAiLanguageModel2 } from "@effect/ai-openai-compat";
 import { Config as Config3, Layer as Layer4, Redacted as Redacted3 } from "effect";
 import { FetchHttpClient as FetchHttpClient4 } from "effect/unstable/http";
@@ -108,7 +112,7 @@ var clientLayerConfig = (options) => OpenAiClient3.layerConfig({
   ...options.baseUrl === undefined ? {} : { apiUrl: Config3.succeed(options.baseUrl) }
 });
 var withOpenAiCompatible = (options) => exports_model_registry.layerFromRegistrationEffects([openAiCompatible(options)]).pipe(Layer4.provide(clientLayerConfig(options)), Layer4.provide(FetchHttpClient4.layer));
-// ../../node_modules/.bun/@batonfx+providers@0.4.3/node_modules/@batonfx/providers/dist/openrouter.js
+// ../../node_modules/.bun/@batonfx+providers@0.4.4/node_modules/@batonfx/providers/dist/openrouter.js
 import { OpenRouterClient, OpenRouterLanguageModel } from "@effect/ai-openrouter";
 import { Config as Config4, Layer as Layer5, Redacted as Redacted4 } from "effect";
 import { FetchHttpClient as FetchHttpClient5 } from "effect/unstable/http";

package/dist/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   exports_language_model_registration
-} from "./index-qg0hy7s1.js";
+} from "./index-per7tyzq.js";
 import {
   Service,
   exports_client,
@@ -9,7 +9,7 @@ import {
   exports_operation,
   exports_runtime,
   makeDatabaseIdentity
-} from "./index-gb7d1wfm.js";
+} from "./index-a6vwwhcp.js";
 import {
   Dialect,
   __export,
@@ -62,7 +62,7 @@ import {
   fromDbTimestamp,
   fromNullableDbTimestamp,
   timestampParam
-} from "./index-9q3yh32k.js";
+} from "./index-5x686v8w.js";
 
 // src/adapter-outbox.ts
 var exports_adapter_outbox = {};
@@ -76,7 +76,7 @@ __export(exports_adapter_outbox, {
   Service: () => Service2
 });
 import { Context, Effect, Layer } from "effect";
-class Service2 extends Context.Service()("@relayfx/sdk/AdapterOutbox") {
+class Service2 extends Context.Service()("@relayfx/sdk/adapter-outbox/Service") {
 }
 var layer = Layer.effect(Service2, Effect.gen(function* () {
   const client = yield* Service;
@@ -151,7 +151,7 @@ import { sql } from "drizzle-orm";
 import { Config, Context as Context2, Effect as Effect2, Layer as Layer2, Redacted } from "effect";
 import { types } from "pg";
 
-class Service3 extends Context2.Service()("@relayfx/store-sql/Database") {
+class Service3 extends Context2.Service()("@relayfx/store-sql/database/database-service/Service") {
 }
 var pgTypeParsers = {
   getTypeParser: (typeId, format) => {

package/dist/mysql.js

@@ -3,12 +3,16 @@ import {
   normalizeClientLayer,
   normalizeMigrationCause,
   runtimeDatabaseLayer
-} from "./index-15f2ewt8.js";
-import"./index-gb7d1wfm.js";
-import"./index-9q3yh32k.js";
+} from "./index-6dv1dqq1.js";
+import {
+  MigratorError,
+  RuntimeMigrationError,
+  SqlFailure
+} from "./index-a6vwwhcp.js";
+import"./index-5x686v8w.js";
 
 // src/mysql.ts
-import { Effect } from "effect";
+import { Effect, Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 
 // ../../migrations/mysql/0001_baseline.sql
@@ -94,8 +98,14 @@ var verifySchema = Effect.gen(function* () {
   const rows = yield* sql`SELECT migration_id, name FROM relay_migrations ORDER BY migration_id`;
   const actual = rows.map((row) => `${row.migration_id}:${row.name}`).join(",");
   const expected = migrations.map(([id, name]) => `${id}:${name}`).join(",");
-  if (actual !== expected)
-    return yield* Effect.fail(new Error(`expected ${expected}; actual ${actual}`));
+  if (actual !== expected) {
+    return yield* RuntimeMigrationError.make({
+      dialect: "mysql",
+      phase: "verify",
+      nextAction: "inspect-schema",
+      cause: SqlFailure.make({ category: "statement", operation: "verify", retryable: false })
+    });
+  }
 }).pipe((effect) => normalizeMigrationCause(effect, "mysql", "verify"));
 var runMigrations = Effect.gen(function* () {
   const sql = yield* SqlClient;
@@ -103,8 +113,13 @@ var runMigrations = Effect.gen(function* () {
   const rows = yield* sql`SELECT migration_id, name FROM relay_migrations ORDER BY migration_id`;
   const current = rows.map((row) => [Number(row.migration_id), row.name]);
   const expectedPrefix = migrations.slice(0, current.length).map(([id, name]) => [id, name]);
-  if (JSON.stringify(current) !== JSON.stringify(expectedPrefix)) {
-    return yield* Effect.fail(new Error(`migration history is not a packaged manifest prefix`));
+  if (current.length !== expectedPrefix.length || current.some(([id, name], index) => expectedPrefix[index]?.[0] !== id || expectedPrefix[index]?.[1] !== name)) {
+    return yield* RuntimeMigrationError.make({
+      dialect: "mysql",
+      phase: "apply",
+      nextAction: "inspect-schema",
+      cause: MigratorError.make({ reason: "migration history is not a packaged manifest prefix" })
+    });
   }
   for (const [id, name, source] of migrations.slice(current.length)) {
     for (const statement of source.split("--> statement-breakpoint").map((value) => value.trim()).filter(Boolean)) {
@@ -113,7 +128,7 @@ var runMigrations = Effect.gen(function* () {
     yield* sql`INSERT INTO relay_migrations (migration_id, name) VALUES (${id}, ${name})`;
   }
 });
-var migrate = (options) => normalizeMigrationCause(runMigrations, "mysql", "apply").pipe(Effect.andThen(normalizeMigrationCause(verifySchema, "mysql", "verify")), Effect.provide(normalizeClientLayer(options.clientLayer)), Effect.asVoid);
+var migrate = (options) => Effect.scoped(Layer.build(normalizeClientLayer(options.clientLayer)).pipe(Effect.flatMap((context) => Effect.provide(normalizeMigrationCause(runMigrations, "mysql", "apply").pipe(Effect.andThen(normalizeMigrationCause(verifySchema, "mysql", "verify"))), context)))).pipe(Effect.asVoid);
 var MySQL = { runtimeDatabaseLayer: runtimeDatabaseLayer2, migrate };
 export {
   runtimeDatabaseLayer2 as runtimeDatabaseLayer,

package/dist/postgres.js

@@ -3,17 +3,19 @@ import {
   normalizeClientLayer,
   normalizeMigrationCause,
   runtimeDatabaseLayer
-} from "./index-15f2ewt8.js";
-import"./index-gb7d1wfm.js";
-import"./index-9q3yh32k.js";
+} from "./index-6dv1dqq1.js";
+import {
+  RuntimeMigrationError,
+  SqlFailure
+} from "./index-a6vwwhcp.js";
+import"./index-5x686v8w.js";
 
 // src/postgres.ts
 import { PgClient } from "@effect/sql-pg/PgClient";
 import { makeWithDefaults } from "drizzle-orm/effect-postgres";
 import { migrate as runDrizzleMigrator } from "drizzle-orm/effect-postgres/migrator";
-import { Effect } from "effect";
+import { Effect, Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { existsSync } from "fs";
 import { fileURLToPath } from "url";
 var schemaHead = "20260712200000_workflow_runtime";
 var migrationNames = [
@@ -43,17 +45,20 @@ var migrationNames = [
   "20260712190000_workflow_definitions",
   schemaHead
 ];
-var migrationsFolder = () => {
-  const packaged = fileURLToPath(new URL("./migrations/pg", import.meta.url));
-  return existsSync(packaged) ? packaged : fileURLToPath(new URL("../../../migrations/pg", import.meta.url));
-};
+var migrationsFolderUrl = import.meta.url.endsWith("/src/postgres.ts") ? new URL("../../../migrations/pg", import.meta.url) : new URL("./migrations/pg", import.meta.url);
+var migrationsFolder = fileURLToPath(migrationsFolderUrl);
 var verifySchema = Effect.gen(function* () {
   const sql = yield* SqlClient;
   const rows = yield* sql`SELECT name FROM drizzle.__drizzle_migrations ORDER BY id`;
   const actual = rows.map((row) => row.name).join(",");
   const expected = migrationNames.join(",");
   if (actual !== expected) {
-    return yield* Effect.fail(new Error(`expected ${expected}; actual ${actual}`));
+    return yield* RuntimeMigrationError.make({
+      dialect: "pg",
+      phase: "verify",
+      nextAction: "inspect-schema",
+      cause: SqlFailure.make({ category: "statement", operation: "verify", retryable: false })
+    });
   }
 }).pipe((effect) => normalizeMigrationCause(effect, "pg", "verify"));
 var runtimeDatabaseLayer2 = (options) => runtimeDatabaseLayer({
@@ -63,12 +68,12 @@ var runtimeDatabaseLayer2 = (options) => runtimeDatabaseLayer({
   schemaHead,
   schema: verifySchema
 });
-var migrate = (options) => normalizeMigrationCause(Effect.gen(function* () {
+var migrate = (options) => Effect.scoped(Layer.build(normalizeClientLayer(options.clientLayer)).pipe(Effect.flatMap((context) => Effect.provide(normalizeMigrationCause(Effect.gen(function* () {
   const sql = yield* SqlClient;
   const pg = sql;
   const database = yield* makeWithDefaults().pipe(Effect.provideService(PgClient, pg));
-  yield* runDrizzleMigrator(database, { migrationsFolder: migrationsFolder() });
-}), "pg", "apply").pipe(Effect.andThen(normalizeMigrationCause(verifySchema, "pg", "verify")), Effect.provide(normalizeClientLayer(options.clientLayer)), Effect.asVoid);
+  yield* runDrizzleMigrator(database, { migrationsFolder });
+}), "pg", "apply").pipe(Effect.andThen(normalizeMigrationCause(verifySchema, "pg", "verify"))), context)))).pipe(Effect.asVoid);
 var Postgres = { runtimeDatabaseLayer: runtimeDatabaseLayer2, migrate };
 export {
   runtimeDatabaseLayer2 as runtimeDatabaseLayer,

package/dist/sqlite.js

@@ -2,7 +2,7 @@
 import {
   normalizeMigrationCause,
   runtimeDatabaseLayer
-} from "./index-15f2ewt8.js";
+} from "./index-6dv1dqq1.js";
 import {
   DatabaseAlreadyOwned,
   DatabaseDialect,
@@ -14,7 +14,7 @@ import {
   exports_operation,
   exports_runtime,
   makeDatabaseIdentity
-} from "./index-gb7d1wfm.js";
+} from "./index-a6vwwhcp.js";
 import {
   __export,
   exports_activity_version_registry,
@@ -59,7 +59,7 @@ import {
   exports_wait_service,
   exports_workflow_definition_repository,
   exports_workflow_schema
-} from "./index-9q3yh32k.js";
+} from "./index-5x686v8w.js";
 // src/sqlite-runtime.ts
 var exports_sqlite_runtime = {};
 __export(exports_sqlite_runtime, {
@@ -72,10 +72,9 @@ __export(exports_sqlite_runtime, {
 });
 import { layer as sqliteClientLayer } from "@effect/sql-sqlite-bun/SqliteClient";
 import { layer as sqliteMigratorLayer, run as runSqliteMigrator } from "@effect/sql-sqlite-bun/SqliteMigrator";
-import { Effect as Effect2, Layer } from "effect";
+import { layer as bunServicesLayer } from "@effect/platform-bun/BunServices";
+import { Effect as Effect2, FileSystem, Function, Layer, Path } from "effect";
 import { SqlClient as SqlClient2 } from "effect/unstable/sql/SqlClient";
-import { dirname, resolve } from "path";
-import { realpathSync } from "fs";
 
 // ../../migrations/sqlite/0001_baseline.sql
 var _0001_baseline_default = `CREATE TABLE "relay_address_book_entries" (
@@ -683,27 +682,25 @@ var loader = Effect.succeed(migrations.map(({ id, name, source }) => [id, name,
 var clientLayer = (options) => sqliteClientLayer(options);
 var memoryIdentity = 0;
 var ownedDatabases = new Set;
-var canonicalFilename = (filename) => {
-  const absolute = resolve(filename);
-  try {
-    return realpathSync(absolute);
-  } catch {
-    try {
-      return resolve(realpathSync(dirname(absolute)), absolute.slice(dirname(absolute).length + 1));
-    } catch {
-      return absolute;
-    }
-  }
-};
+var canonicalFilename = Effect2.fn("SQLite.canonicalFilename")(function* (filename) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const absolute = path.resolve(filename);
+  return yield* fs.realPath(absolute).pipe(Effect2.catch(() => fs.realPath(path.dirname(absolute)).pipe(Effect2.map((parent) => path.resolve(parent, path.basename(absolute))), Effect2.orElseSucceed(() => absolute))));
+});
 var runtimeDatabaseLayer2 = (options) => {
   if (options.filename.length === 0) {
-    return Object.assign(Layer.effectContext(Effect2.fail(new RuntimeConfigurationError({
+    return Object.assign(Layer.effectContext(Effect2.fail(RuntimeConfigurationError.make({
       setting: "filename",
       nextAction: "provide-setting",
       cause: { _tag: "ConfigFailure", reason: "SQLite Runtime requires a non-empty filename" }
     }))), { [DatabaseDialect]: "sqlite" });
   }
-  const filename = options.filename === ":memory:" ? options.filename : canonicalFilename(options.filename);
+  const resolvedFilename = options.filename === ":memory:" ? Effect2.succeed(options.filename) : Effect2.scoped(Layer.build(bunServicesLayer).pipe(Effect2.flatMap((context) => Effect2.provide(canonicalFilename(options.filename), context))));
+  const database = Layer.unwrap(resolvedFilename.pipe(Effect2.map((filename) => makeSqliteDatabaseLayer(options, filename))));
+  return Object.assign(database, { [DatabaseDialect]: "sqlite" });
+};
+var makeSqliteDatabaseLayer = (options, filename) => {
   const identity = options.filename === ":memory:" ? `sqlite:memory:${memoryIdentity++}` : `sqlite:file:${filename}`;
   const databaseIdentity = makeDatabaseIdentity(identity);
   const acquireSchema = Effect2.gen(function* () {
@@ -713,11 +710,11 @@ var runtimeDatabaseLayer2 = (options) => {
     const actual = rows.map((row) => `${row.migration_id}:${row.name}`).join(",");
     const expected = migrations.map((migration) => `${migration.id}:${migration.name}`).join(",");
     if (actual !== expected) {
-      return yield* new RuntimeMigrationError({
+      return yield* RuntimeMigrationError.make({
         dialect: "sqlite",
         phase: "verify",
         nextAction: "run-compatible-release",
-        cause: new SchemaHeadMismatch({ expected, actual })
+        cause: SchemaHeadMismatch.make({ expected, actual })
       });
     }
   });
@@ -731,18 +728,18 @@ var runtimeDatabaseLayer2 = (options) => {
   });
   const ownership = Layer.effectDiscard(Effect2.acquireRelease(Effect2.suspend(() => {
     if (ownedDatabases.has(identity)) {
-      return Effect2.fail(new RuntimeTopologyError({
+      return Effect2.fail(RuntimeTopologyError.make({
         dialect: "sqlite",
         role: "embedded",
         nextAction: "reuse-runtime",
-        cause: new DatabaseAlreadyOwned({ databaseIdentity })
+        cause: DatabaseAlreadyOwned.make({ databaseIdentity })
       }));
     }
     ownedDatabases.add(identity);
     return Effect2.void;
   }), () => Effect2.sync(() => ownedDatabases.delete(identity))));
   const ownedDatabase = database.pipe(Layer.provideMerge(ownership));
-  return Object.assign(ownedDatabase, { [DatabaseDialect]: "sqlite" });
+  return ownedDatabase;
 };
 var migrationOptions = {
   loader,
@@ -757,18 +754,18 @@ var layer = (options) => {
     return sql;
   })).pipe(Layer.provide(client));
 };
-var workflowLayer = (options, handlersLayer) => {
+var workflowLayer = Function.dual(2, (options, handlersLayer) => {
   const sqlite = layer(options);
   const repository = exports_workflow_definition_repository.layer.pipe(Layer.provideMerge(sqlite));
   return exports_definition_runtime.layer.pipe(Layer.provideMerge(handlersLayer), Layer.provideMerge(repository));
-};
-var childFanOutLayer = (options, handlersLayer) => {
+});
+var childFanOutLayer = Function.dual(2, (options, handlersLayer) => {
   const sqlite = layer(options);
   const repository = exports_child_fan_out_repository.layer.pipe(Layer.provideMerge(sqlite));
   const events = exports_event_log_service.layerFromRepository.pipe(Layer.provide(exports_execution_event_repository.layer.pipe(Layer.provide(exports_notification_bus.inProcessLayer))), Layer.provideMerge(sqlite));
   const transitions = exports_child_fan_out_transition_service.layer.pipe(Layer.provide(repository), Layer.provide(events));
   return exports_child_fan_out_runtime.layer.pipe(Layer.provide(handlersLayer), Layer.provide(repository), Layer.provide(transitions));
-};
+});
 
 // src/sqlite.ts
 var relaySqlitePackage = "@relayfx/sdk/sqlite";

package/dist/types/ai/embedding-model/embedding-model-registration.d.ts

@@ -3,7 +3,7 @@ import { OpenAiClient as OpenAiCompatibleClient, OpenAiEmbeddingModel as OpenAiC
 import { EmbeddingModelService } from "../../runtime/index";
 export interface OpenAiEmbeddingInput {
     readonly model: OpenAiEmbeddingModel.Model | (string & {});
-    readonly dimensions?: number | undefined;
+    readonly dimensions: number;
     readonly config?: Omit<typeof OpenAiEmbeddingModel.Config.Service, "model" | "dimensions"> | undefined;
     readonly registrationKey?: string | undefined;
     readonly provider?: string | undefined;
@@ -11,7 +11,7 @@ export interface OpenAiEmbeddingInput {
 }
 export interface OpenAiCompatibleEmbeddingInput {
     readonly model: string;
-    readonly dimensions?: number | undefined;
+    readonly dimensions: number;
     readonly config?: Omit<typeof OpenAiCompatibleEmbeddingModel.Config.Service, "model" | "dimensions"> | undefined;
     readonly registrationKey?: string | undefined;
     readonly provider?: string | undefined;

package/dist/types/relay/adapter-outbox.d.ts

@@ -7,7 +7,7 @@ export interface Interface {
     readonly release: (input: ReleaseEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyReleased, ClientError>;
     readonly submitInbound: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, WaitKindMismatch | ClientError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/AdapterOutbox", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/adapter-outbox/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, ClientService>;

package/dist/types/relay/client.d.ts

@@ -112,14 +112,14 @@ export interface Interface {
     readonly registerAgent: (input: RegisterAgentInput) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
     readonly getAgentDefinition: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
-    readonly listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError>;
+    readonly listAgentDefinitions: (_?: void) => Effect.Effect<Agent.DefinitionList, ClientError>;
     readonly listAgentDefinitionRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, ClientError>;
     readonly getSkillDefinition: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRecord | undefined, ClientError>;
-    readonly listSkillDefinitions: () => Effect.Effect<Skill.DefinitionList, ClientError>;
+    readonly listSkillDefinitions: (_?: void) => Effect.Effect<Skill.DefinitionList, ClientError>;
     readonly listSkillDefinitionRevisions: (id: Ids.SkillDefinitionId) => Effect.Effect<Skill.DefinitionRevisionList, ClientError>;
     readonly registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, EntityNamespaceReserved | ClientError>;
     readonly getAddressBookRoute: (id: Ids.AddressId) => Effect.Effect<Address.RouteRecord | undefined, ClientError>;
-    readonly listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError>;
+    readonly listAddressBookRoutes: (_?: void) => Effect.Effect<Address.RouteList, ClientError>;
     readonly startExecution: (input: StartExecutionInput) => Effect.Effect<StartExecutionResult, EntityNamespaceReserved | ClientError>;
     readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<StartExecutionResult, EntityNamespaceReserved | ClientError>;
     readonly startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<StartExecutionResult, EntityNamespaceReserved | ClientError>;
@@ -137,7 +137,7 @@ export interface Interface {
     readonly getSession: (input: GetSessionInput) => Effect.Effect<GetSessionResult, ClientError>;
     readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitView>, ClientError>;
     readonly replayExecution: (input: ReplayExecutionInput) => Effect.Effect<ReplayExecutionResult, ClientError>;
-    readonly listRunners: () => Effect.Effect<ListRunnersResult, ClientError>;
+    readonly listRunners: (_?: void) => Effect.Effect<ListRunnersResult, ClientError>;
     readonly routeExecution: (executionId: Ids.ExecutionId) => Effect.Effect<RouteExecutionResult, ClientError>;
     readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError>;
     readonly askEntity: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskEntityInput<Name, I, O>) => Effect.Effect<O["Type"], CommandTimedOut | CommandReplyInvalid | EntityNotFound | ClientError, I["EncodingServices"] | O["DecodingServices"]>;
@@ -174,7 +174,7 @@ export interface Interface {
     readonly cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<CancelScheduleResult, ClientError>;
     readonly listSchedules: (input: ListSchedulesInput) => Effect.Effect<ListSchedulesResult, ClientError>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/Client", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/client/Service", Interface>;
 export declare class Service extends Service_base {
 }
 export interface FollowExecutionDependencies {
@@ -222,7 +222,7 @@ export declare const listTopicSubscriptions: (input: ListTopicSubscriptionsInput
 export declare const listInboxMessages: (input: ListInboxMessagesInput) => Effect.Effect<readonly Inbox.Message[], ClientError, Service>;
 export declare const inspectExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<ExecutionInspection, ClientError | ExecutionNotFound, Service>;
 export declare const send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError, Service>;
-export declare const streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, EventLogCursorNotFound | ClientError, Service>;
+export declare const streamExecution: (input: StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError | EventLogCursorNotFound, Service>;
 export declare const followExecution: (input: FollowExecutionInput) => Stream.Stream<Schema.Struct.ReadonlySide<{
     readonly _tag: Schema.tag<"event">;
     readonly event: Schema.Struct<{
@@ -321,7 +321,7 @@ export declare const followExecution: (input: FollowExecutionInput) => Stream.St
         }>;
     }>]>;
     readonly cursor: Schema.NullOr<Schema.String>;
-}, "Type">, EventLogCursorNotFound | ClientError, Service>;
+}, "Type">, ClientError | EventLogCursorNotFound, Service>;
 export declare const streamSession: (input: StreamSessionInput) => Stream.Stream<Schema.Struct.ReadonlySide<{
     readonly _tag: Schema.tag<"execution_joined">;
     readonly execution: Schema.Struct<{
@@ -410,24 +410,8 @@ export declare const streamSession: (input: StreamSessionInput) => Stream.Stream
         readonly data: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         readonly created_at: Schema.Int;
     }>;
-}, "Type">, EventLogCursorNotFound | ClientError, Service>;
-export declare const watchExecutions: (input: WatchExecutionsInput) => Stream.Stream<{
-    readonly records: readonly {
-        readonly metadata: {
-            readonly [x: string]: Schema.Json;
-        };
-        readonly kind: "user-agent" | "agent-agent";
-        readonly created_at: number;
-        readonly updated_at: number;
-        readonly root_address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
-        readonly status: "waiting" | "running" | "completed" | "failed" | "queued" | "cancelled";
-        readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-        readonly session_id?: string & import("effect/Brand").Brand<"Relay.SessionId">;
-        readonly agent_id?: string & import("effect/Brand").Brand<"Relay.AgentId">;
-    }[];
-    readonly _tag: "snapshot";
-    readonly next_cursor?: string;
-} | Schema.Struct.ReadonlySide<{
+}, "Type">, ClientError | EventLogCursorNotFound, Service>;
+export declare const watchExecutions: (input: WatchExecutionsInput) => Stream.Stream<Schema.Struct.ReadonlySide<{
     readonly _tag: Schema.tag<"upsert">;
     readonly record: Schema.Struct<{
         readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
@@ -448,7 +432,23 @@ export declare const watchExecutions: (input: WatchExecutionsInput) => Stream.St
         readonly created_at: Schema.Int;
         readonly updated_at: Schema.Int;
     }>;
-}, "Type">, ClientError, Service>;
+}, "Type"> | {
+    readonly _tag: "snapshot";
+    readonly records: readonly {
+        readonly execution_id: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+        readonly root_address_id: string & import("effect/Brand").Brand<"Relay.AddressId">;
+        readonly session_id?: string & import("effect/Brand").Brand<"Relay.SessionId">;
+        readonly status: "cancelled" | "completed" | "failed" | "queued" | "running" | "waiting";
+        readonly kind: "agent-agent" | "user-agent";
+        readonly agent_id?: string & import("effect/Brand").Brand<"Relay.AgentId">;
+        readonly metadata: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly created_at: number;
+        readonly updated_at: number;
+    }[];
+    readonly next_cursor?: string;
+}, ClientError, Service>;
 export declare const getPresence: (scope: Presence.Scope) => Effect.Effect<Presence.View, ClientError, Service>;
 export declare const watchPresence: (scope: Presence.Scope) => Stream.Stream<Presence.View, ClientError, Service>;
 export declare const wake: (input: WakeInput) => Effect.Effect<WakeAccepted, ClientError | WaitKindMismatch, Service>;
@@ -463,7 +463,7 @@ export declare const releaseToolWork: (input: ReleaseToolWorkInput) => Effect.Ef
 export declare const listToolAttempts: (input: ListToolAttemptsInput) => Effect.Effect<ToolAttemptList, ClientError, Service>;
 export declare const submitInboundEnvelope: (input: SubmitInboundEnvelopeInput) => Effect.Effect<SubmitInboundEnvelopeAccepted, ClientError | WaitKindMismatch, Service>;
 export declare const spawnChildRun: (input: SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError, Service>;
-export declare const createChildFanOut: (input: CreateChildFanOutInput) => Effect.Effect<ChildOrchestration.FanOutState, RuntimeCapabilityUnavailable | ClientError, Service>;
+export declare const createChildFanOut: (input: CreateChildFanOutInput) => Effect.Effect<ChildOrchestration.FanOutState, ClientError | RuntimeCapabilityUnavailable, Service>;
 export declare const cancelChildFanOut: (input: CancelChildFanOutInput) => Effect.Effect<CancelChildFanOutResult, ClientError, Service>;
 export declare const inspectChildFanOut: (input: InspectChildFanOutInput) => Effect.Effect<InspectChildFanOutResult, ClientError, Service>;
 export declare const claimEnvelopeReady: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError, Service>;
@@ -472,5 +472,5 @@ export declare const releaseEnvelopeReady: (input: ReleaseEnvelopeReadyInput) =>
 export declare const createSchedule: (input: CreateScheduleInput) => Effect.Effect<CreateScheduleResult, ClientError, Service>;
 export declare const cancelSchedule: (input: CancelScheduleInput) => Effect.Effect<CancelScheduleResult, ClientError, Service>;
 export declare const listSchedules: (input: ListSchedulesInput) => Effect.Effect<ListSchedulesResult, ClientError, Service>;
-export declare const askEntity: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskEntityInput<Name, I, O>) => Effect.Effect<O["Type"], CommandTimedOut | CommandReplyInvalid | EntityNotFound | ClientError, Service | I["EncodingServices"] | O["DecodingServices"]>;
+export declare const askEntity: <Name extends string, I extends Schema.Top, O extends Schema.Top>(input: AskEntityInput<Name, I, O>) => Effect.Effect<O["Type"], ClientError | CommandReplyInvalid | CommandTimedOut | EntityNotFound, Service | I["EncodingServices"] | O["DecodingServices"]>;
 export declare const awaitWait: (input: AwaitWaitInput) => Effect.Effect<WaitOutcome, ClientError, Service>;

package/dist/types/relay/command.d.ts

@@ -4,10 +4,16 @@ export interface Command<Name extends string, Input extends Schema.Top, Output e
     readonly input: Input;
     readonly output: Output;
 }
-export declare const make: <Name extends string, Input extends Schema.Top, Output extends Schema.Top>(name: Name, options: {
-    readonly input: Input;
-    readonly output: Output;
-}) => Command<Name, Input, Output>;
+export declare const make: {
+    <Input extends Schema.Top, Output extends Schema.Top>(options: {
+        readonly input: Input;
+        readonly output: Output;
+    }): <Name extends string>(name: Name) => Command<Name, Input, Output>;
+    <Name extends string, Input extends Schema.Top, Output extends Schema.Top>(name: Name, options: {
+        readonly input: Input;
+        readonly output: Output;
+    }): Command<Name, Input, Output>;
+};
 export declare const inputSchemaRef: (name: string) => string;
 export declare const outputSchemaRef: (name: string) => string;
 declare const CommandTimedOut_base: Schema.Class<CommandTimedOut, Schema.TaggedStruct<"CommandTimedOut", {

package/dist/types/relay/database.d.ts

@@ -3,14 +3,14 @@ import type { Context, Effect } from "effect";
 export type Drizzle = Context.Service.Shape<typeof Database.Service>;
 export type PgTimestamp = Parameters<typeof Database.fromPgDate>[0];
 export type DatabaseError = Effect.Error<ReturnType<typeof Database.check>>;
-export type Dialect = typeof Database.Dialect.Type;
+export type Dialect = Database.Dialect;
 export declare const Service: typeof Database.Service;
-export declare const PgClientLive: import("effect/Layer").Layer<import("effect/unstable/sql/SqlClient").SqlClient | import("@effect/sql-pg/PgClient").PgClient, import("effect/unstable/sql/SqlError").SqlError | import("effect/Config").ConfigError, never>;
+export declare const PgClientLive: import("effect/Layer").Layer<import("@effect/sql-pg/PgClient").PgClient | import("effect/unstable/sql/SqlClient").SqlClient, import("effect/Config").ConfigError | import("effect/unstable/sql/SqlError").SqlError, never>;
 export declare const layerFromPgClient: import("effect/Layer").Layer<Database.Service, never, import("@effect/sql-pg/PgClient").PgClient>;
-export declare const testLayer: (db: Database.Drizzle) => import("effect/Layer").Layer<Database.Service, never, never>;
+export declare const testLayer: typeof Database.testLayer;
 export declare const check: () => Effect.Effect<void, import("drizzle-orm/effect-core").EffectDrizzleQueryError, Database.Service>;
 export declare const pgTypeParsers: {
     getTypeParser: (typeId: number, format?: "text" | "binary") => any;
 };
 export declare const Dialect: import("effect/Schema").Literals<readonly ["pg", "mysql", "sqlite"]>;
-export declare const dialect: Effect.Effect<"pg" | "mysql" | "sqlite", never, import("effect/unstable/sql/SqlClient").SqlClient>;
+export declare const dialect: Effect.Effect<"mysql" | "pg" | "sqlite", never, import("effect/unstable/sql/SqlClient").SqlClient>;

package/dist/types/relay/migration-errors.d.ts

@@ -1,4 +1,10 @@
 import { Effect } from "effect";
 import { RuntimeMigrationError, type Dialect } from "./runtime";
-export declare const migrationFailure: (dialect: Dialect, phase: "apply" | "verify", cause: unknown) => RuntimeMigrationError;
-export declare const normalizeMigrationCause: <A, E, R>(effect: Effect.Effect<A, E, R>, dialect: Dialect, phase: "apply" | "verify") => Effect.Effect<A, RuntimeMigrationError, R>;
+export declare const migrationFailure: {
+    (phase: "apply" | "verify", cause: unknown): (dialect: Dialect) => RuntimeMigrationError;
+    (dialect: Dialect, phase: "apply" | "verify", cause: unknown): RuntimeMigrationError;
+};
+export declare const normalizeMigrationCause: {
+    (dialect: Dialect, phase: "apply" | "verify"): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, RuntimeMigrationError, R>;
+    <A, E, R>(effect: Effect.Effect<A, E, R>, dialect: Dialect, phase: "apply" | "verify"): Effect.Effect<A, RuntimeMigrationError, R>;
+};

package/dist/types/relay/mysql.d.ts

@@ -1,6 +1,6 @@
-import { Effect, type Layer } from "effect";
+import { Effect, Layer } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-import type { DatabaseIdentity, DatabaseLayer, RuntimeConfigurationError, RuntimeMigrationError } from "./runtime";
+import { RuntimeMigrationError, type DatabaseIdentity, type DatabaseLayer, type RuntimeConfigurationError } from "./runtime";
 export interface MySQLRuntimeDatabaseOptions<E, R> {
     readonly clientLayer: Layer.Layer<SqlClient, E, R>;
     readonly databaseIdentity: DatabaseIdentity;