@relayfx/sdk 0.7.12 → 0.7.13

package/dist/{index-agr4t5nk.js → index-fn3rdmbr.js}

@@ -8,7 +8,7 @@ import {
   SqlFailure,
   make,
   normalizeAcquisitionCause
-} from "./index-chbsjf5d.js";
+} from "./index-0fta2cfp.js";
 
 // src/migration-errors.ts
 import { Cause, Effect, Function } from "effect";

package/dist/index.js

@@ -14,7 +14,7 @@ import {
   exports_tool_runtime,
   exports_workflow_definition_host,
   makeDatabaseIdentity
-} from "./index-chbsjf5d.js";
+} from "./index-0fta2cfp.js";
 import {
   exports_context_overflow,
   exports_model_registry
@@ -148,6 +148,16 @@ var run = Effect2.fn("ToolWorker.run")(function* (options) {
   return yield* runOnce(options).pipe(Effect2.catch((error) => Effect2.logWarning("relay tool worker poll failed", { message: error.message }).pipe(Effect2.as(false))), Effect2.flatMap((worked) => worked ? Effect2.void : Effect2.sleep(pollInterval)), Effect2.forever);
 });
 
+// src/event-history.ts
+var exports_event_history = {};
+__export(exports_event_history, {
+  fileSystem: () => fileSystem
+});
+var fileSystem = (options) => ({
+  _tag: "FileSystem",
+  directory: options.directory
+});
+
 // src/language-model-registration.ts
 var exports_language_model_registration = {};
 __export(exports_language_model_registration, {
@@ -1044,6 +1054,7 @@ var Command = exports_command;
 var Operation = exports_operation;
 var ToolWorker = exports_tool_worker;
 var Runtime = exports_runtime;
+var EventHistory = exports_event_history;
 var WorkflowDefinitionHost = exports_workflow_definition_host;
 var ArtifactStore = exports_artifact_store_service;
 var BlobStore = exports_blob_store_service;
@@ -1079,6 +1090,7 @@ export {
   exports_inbox_schema as Inbox,
   exports_ids_schema as Ids,
   exports_execution_schema as Execution,
+  EventHistory,
   exports_envelope_schema as Envelope,
   EmbeddingModelService,
   DatabaseIdentity,

package/dist/migrations/20260725010000_event_history_binding/migration.sql

@@ -0,0 +1,8 @@
+CREATE TABLE "relay_event_history_bindings" (
+  "binding_key" integer PRIMARY KEY NOT NULL,
+  "store_identity" text NOT NULL,
+  "state" text NOT NULL,
+  CONSTRAINT "ck_relay_event_history_bindings_singleton" CHECK ("binding_key" = 1),
+  CONSTRAINT "ck_relay_event_history_bindings_identity" CHECK (length("store_identity") = 64),
+  CONSTRAINT "ck_relay_event_history_bindings_state" CHECK ("state" IN ('allocating', 'publishing', 'ready'))
+);

package/dist/migrations/mysql/0019_event_history_binding.sql

@@ -0,0 +1,9 @@
+CREATE TABLE `relay_event_history_bindings` (
+  `binding_key` integer NOT NULL,
+  `store_identity` varchar(64) NOT NULL,
+  `state` varchar(16) NOT NULL,
+  CONSTRAINT `pk_relay_event_history_bindings` PRIMARY KEY (`binding_key`),
+  CONSTRAINT `ck_relay_event_history_bindings_singleton` CHECK (`binding_key` = 1),
+  CONSTRAINT `ck_relay_event_history_bindings_identity` CHECK (char_length(`store_identity`) = 64),
+  CONSTRAINT `ck_relay_event_history_bindings_state` CHECK (`state` IN ('allocating', 'publishing', 'ready'))
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;

package/dist/migrations/pg/20260725010000_event_history_binding/migration.sql

@@ -0,0 +1,8 @@
+CREATE TABLE "relay_event_history_bindings" (
+  "binding_key" integer PRIMARY KEY NOT NULL,
+  "store_identity" text NOT NULL,
+  "state" text NOT NULL,
+  CONSTRAINT "ck_relay_event_history_bindings_singleton" CHECK ("binding_key" = 1),
+  CONSTRAINT "ck_relay_event_history_bindings_identity" CHECK (length("store_identity") = 64),
+  CONSTRAINT "ck_relay_event_history_bindings_state" CHECK ("state" IN ('allocating', 'publishing', 'ready'))
+);

package/dist/migrations/sqlite/0019_event_history_binding.sql

@@ -0,0 +1,8 @@
+CREATE TABLE "relay_event_history_bindings" (
+  "binding_key" integer PRIMARY KEY NOT NULL,
+  "store_identity" text NOT NULL,
+  "state" text NOT NULL,
+  CONSTRAINT "ck_relay_event_history_bindings_singleton" CHECK ("binding_key" = 1),
+  CONSTRAINT "ck_relay_event_history_bindings_identity" CHECK (length("store_identity") = 64),
+  CONSTRAINT "ck_relay_event_history_bindings_state" CHECK ("state" IN ('allocating', 'publishing', 'ready'))
+);

package/dist/mysql.js

@@ -2,12 +2,12 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-agr4t5nk.js";
+} from "./index-fn3rdmbr.js";
 import {
   MigratorError,
   RuntimeMigrationError,
   SqlFailure
-} from "./index-chbsjf5d.js";
+} from "./index-0fta2cfp.js";
 import"./index-d5563j6w.js";
 import"./index-j8k41y47.js";
 import"./index-nb39b5ae.js";
@@ -109,6 +109,9 @@ var _0017_execution_event_identity_directory_default = "CREATE TABLE IF NOT EXIS
 // ../../migrations/mysql/0018_idempotent_steering.sql
 var _0018_idempotent_steering_default = "ALTER TABLE `relay_steering_messages` ADD COLUMN `idempotency_key` varchar(191) COLLATE utf8mb4_bin;\n--> statement-breakpoint\nUPDATE `relay_steering_messages` SET `idempotency_key` = CONCAT('relay:legacy:', `kind`, ':', `sequence`);\n--> statement-breakpoint\nALTER TABLE `relay_steering_messages` MODIFY COLUMN `idempotency_key` varchar(191) COLLATE utf8mb4_bin NOT NULL;\n--> statement-breakpoint\nCREATE UNIQUE INDEX `uq_relay_steering_messages_idempotency` ON `relay_steering_messages` (`tenant_id`, `execution_id`, `idempotency_key`);\n";
 
+// ../../migrations/mysql/0019_event_history_binding.sql
+var _0019_event_history_binding_default = "CREATE TABLE `relay_event_history_bindings` (\n  `binding_key` integer NOT NULL,\n  `store_identity` varchar(64) NOT NULL,\n  `state` varchar(16) NOT NULL,\n  CONSTRAINT `pk_relay_event_history_bindings` PRIMARY KEY (`binding_key`),\n  CONSTRAINT `ck_relay_event_history_bindings_singleton` CHECK (`binding_key` = 1),\n  CONSTRAINT `ck_relay_event_history_bindings_identity` CHECK (char_length(`store_identity`) = 64),\n  CONSTRAINT `ck_relay_event_history_bindings_state` CHECK (`state` IN ('allocating', 'publishing', 'ready'))\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;\n";
+
 // src/mysql-migrations.ts
 var migrations = [
   [1, "baseline", _0001_baseline_default],
@@ -128,10 +131,85 @@ var migrations = [
   [15, "transactional_event_head", _0015_transactional_event_head_default],
   [16, "execution_event_archive_manifests", _0016_execution_event_archive_manifests_default],
   [17, "execution_event_identity_directory", _0017_execution_event_identity_directory_default],
-  [18, "idempotent_steering", _0018_idempotent_steering_default]
+  [18, "idempotent_steering", _0018_idempotent_steering_default],
+  [19, "event_history_binding", _0019_event_history_binding_default]
 ];
 
 // src/mysql.ts
+var migration19Failure = () => RuntimeMigrationError.make({
+  dialect: "mysql",
+  phase: "apply",
+  nextAction: "inspect-schema",
+  cause: MigratorError.make({ reason: "migration 19 table exists with an unexpected catalog shape" })
+});
+var normalizeCheckClause = (value) => (value.match(/'(?:''|[^'])*'|[^']+/g) ?? []).map((part) => part.startsWith("'") ? part : part.toLowerCase().replace(/_[a-z0-9]+$/g, "").replace(/[`()\s]/g, "")).join("");
+var rowsEqual = (left, right) => left.length === right.length && left.every((row, index) => row.every((value, column) => value === right[index]?.[column]));
+var reconcileMigration19 = Effect.fn("MySQL.reconcileMigration19")(function* (connection) {
+  const tables = yield* connection.execute(`SELECT t.engine AS engine, t.table_collation AS table_collation
+       FROM information_schema.tables t
+      WHERE t.table_schema = DATABASE() AND t.table_name = 'relay_event_history_bindings'`, [], undefined);
+  if (tables.length === 0)
+    return false;
+  if (tables.length !== 1)
+    return yield* migration19Failure();
+  const table = tables[0];
+  if (table.engine?.toLowerCase() !== "innodb" || table.table_collation !== "utf8mb4_unicode_ci") {
+    return yield* migration19Failure();
+  }
+  const columns = yield* connection.execute(`SELECT ordinal_position, column_name, data_type, column_type, is_nullable,
+            character_maximum_length, collation_name, column_default, extra
+       FROM information_schema.columns
+      WHERE table_schema = DATABASE() AND table_name = 'relay_event_history_bindings'
+      ORDER BY ordinal_position`, [], undefined);
+  const expectedColumns = [
+    [1, "binding_key", "int", "int", "NO", null, null, null, ""],
+    [2, "store_identity", "varchar", "varchar(64)", "NO", 64, "utf8mb4_unicode_ci", null, ""],
+    [3, "state", "varchar", "varchar(16)", "NO", 16, "utf8mb4_unicode_ci", null, ""]
+  ];
+  const actualColumns = columns.map((column) => [
+    Number(column.ordinal_position),
+    column.column_name,
+    column.data_type,
+    column.column_type,
+    column.is_nullable,
+    column.character_maximum_length === null ? null : Number(column.character_maximum_length),
+    column.collation_name,
+    column.column_default,
+    column.extra
+  ]);
+  if (!rowsEqual(actualColumns, expectedColumns))
+    return yield* migration19Failure();
+  const constraints = yield* connection.execute(`SELECT tc.constraint_name, tc.constraint_type, tc.enforced, cc.check_clause
+       FROM information_schema.table_constraints tc
+       LEFT JOIN information_schema.check_constraints cc
+         ON tc.constraint_type = 'CHECK'
+        AND cc.constraint_schema = tc.constraint_schema AND cc.constraint_name = tc.constraint_name
+      WHERE tc.constraint_schema = DATABASE() AND tc.table_name = 'relay_event_history_bindings'
+      ORDER BY tc.constraint_name`, [], undefined);
+  const actualConstraints = constraints.map((constraint) => [
+    constraint.constraint_name,
+    constraint.constraint_type,
+    constraint.constraint_type === "CHECK" ? constraint.enforced : null,
+    typeof constraint.check_clause === "string" ? normalizeCheckClause(constraint.check_clause) : null
+  ]).toSorted((left, right) => String(left[0]).localeCompare(String(right[0]), "en"));
+  const expectedConstraints = [
+    ["PRIMARY", "PRIMARY KEY", null, null],
+    ["ck_relay_event_history_bindings_identity", "CHECK", "YES", "char_lengthstore_identity=64"],
+    ["ck_relay_event_history_bindings_singleton", "CHECK", "YES", "binding_key=1"],
+    ["ck_relay_event_history_bindings_state", "CHECK", "YES", "statein'allocating','publishing','ready'"]
+  ].toSorted((left, right) => String(left[0]).localeCompare(String(right[0]), "en"));
+  if (!rowsEqual(actualConstraints, expectedConstraints))
+    return yield* migration19Failure();
+  const primaryKey = yield* connection.execute(`SELECT column_name, ordinal_position
+       FROM information_schema.key_column_usage
+      WHERE constraint_schema = DATABASE() AND table_name = 'relay_event_history_bindings'
+        AND constraint_name = 'PRIMARY'
+      ORDER BY ordinal_position`, [], undefined);
+  if (primaryKey.length !== 1 || primaryKey[0].column_name !== "binding_key" || Number(primaryKey[0].ordinal_position) !== 1) {
+    return yield* migration19Failure();
+  }
+  return true;
+});
 var verifySchema = Effect.gen(function* () {
   const sql = yield* SqlClient;
   const rows = yield* sql`SELECT migration_id, name FROM relay_migrations ORDER BY migration_id`;
@@ -167,6 +245,8 @@ var runMigrations = Effect.gen(function* () {
       return yield* Effect.gen(function* () {
         const migration = yield* Effect.exit(Effect.gen(function* () {
           for (const statement of statements) {
+            if (id === 19 && (yield* reconcileMigration19(connection)))
+              continue;
             if (id === 16) {
               const catalogQuery = statement.includes("ADD COLUMN") ? [
                 "SELECT COUNT(*) AS count FROM information_schema.columns WHERE table_schema = DATABASE() AND table_name = 'relay_execution_event_heads' AND column_name = ?",

package/dist/postgres.js

@@ -2,7 +2,7 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-agr4t5nk.js";
+} from "./index-fn3rdmbr.js";
 import {
   Dialect,
   RuntimeMigrationError,
@@ -14,7 +14,7 @@ import {
   fromDbTimestamp,
   fromNullableDbTimestamp,
   timestampParam
-} from "./index-chbsjf5d.js";
+} from "./index-0fta2cfp.js";
 import"./index-d5563j6w.js";
 import {
   exports_ids_schema
@@ -422,6 +422,16 @@ var relayExecutionEventHeads = pgTable5("relay_execution_event_heads", {
   primaryKey5({ columns: [table.tenantId, table.executionId], name: "pk_relay_execution_event_heads" }),
   check2("ck_relay_execution_event_heads_archive_pointer", sql2`(${table.archivedThrough} IS NULL) = (${table.archiveGeneration} IS NULL)`)
 ]);
+var relayEventHistoryBindings = pgTable5("relay_event_history_bindings", {
+  bindingKey: integer4("binding_key").notNull(),
+  storeIdentity: text6("store_identity").notNull(),
+  state: text6("state").$type().notNull()
+}, (table) => [
+  primaryKey5({ columns: [table.bindingKey], name: "pk_relay_event_history_bindings" }),
+  check2("ck_relay_event_history_bindings_singleton", sql2`${table.bindingKey} = 1`),
+  check2("ck_relay_event_history_bindings_identity", sql2`length(${table.storeIdentity}) = 64`),
+  check2("ck_relay_event_history_bindings_state", sql2`${table.state} IN ('allocating', 'publishing', 'ready')`)
+]);
 var relayExecutionEventArchiveManifests = pgTable5("relay_execution_event_archive_manifests", {
   tenantId: tenantId(),
   executionId: text6("execution_id").$type().notNull(),
@@ -865,8 +875,8 @@ var relayIdempotencyKeys = pgTable13("relay_idempotency_keys", {
   uniqueIndex9("uq_relay_idempotency_scope_operation_key").on(table.tenantId, table.scope, table.operation, table.key)
 ]);
 // src/postgres.ts
-var priorSchemaHead = "20260724120000_execution_event_identity_directory";
-var schemaHead = "20260724230000_idempotent_steering";
+var priorSchemaHead = "20260724230000_idempotent_steering";
+var schemaHead = "20260725010000_event_history_binding";
 var migrationNames = [
   "20260701002839_sour_cerebro",
   "20260701041134_acoustic_hulk",
@@ -899,6 +909,7 @@ var migrationNames = [
   "20260721170000_session_writer_ownership",
   "20260723190000_transactional_event_head",
   "20260724010000_execution_event_archive_manifests",
+  "20260724120000_execution_event_identity_directory",
   priorSchemaHead,
   schemaHead
 ];

package/dist/sqlite.js

@@ -2,17 +2,21 @@
 import {
   database,
   normalizeMigrationCause
-} from "./index-agr4t5nk.js";
+} from "./index-fn3rdmbr.js";
 import {
   DatabaseAlreadyOwned,
+  HostUnavailable,
   RuntimeConfigurationError,
   RuntimeMigrationError,
+  RuntimeReadinessError,
   RuntimeTopologyError,
   SchemaHeadMismatch,
+  UnsupportedTopology,
+  exports_runtime_event_history,
   make,
   makeDatabaseIdentity,
   runtimeLayer
-} from "./index-chbsjf5d.js";
+} from "./index-0fta2cfp.js";
 import"./index-d5563j6w.js";
 import"./index-j8k41y47.js";
 import"./index-nb39b5ae.js";
@@ -21,8 +25,9 @@ import"./index-nb39b5ae.js";
 import { layer as sqliteClientLayer } from "@effect/sql-sqlite-bun/SqliteClient";
 import { run as runSqliteMigrator } from "@effect/sql-sqlite-bun/SqliteMigrator";
 import { layer as bunServicesLayer } from "@effect/platform-bun/BunServices";
-import { Effect as Effect2, FileSystem, Layer, Path } from "effect";
+import { Cause, Effect as Effect2, FileSystem, Layer, Path, Semaphore } from "effect";
 import { SqlClient as SqlClient2 } from "effect/unstable/sql/SqlClient";
+import { resolve } from "path";
 
 // ../../migrations/sqlite/0001_baseline.sql
 var _0001_baseline_default = `CREATE TABLE "relay_address_book_entries" (
@@ -779,6 +784,17 @@ UPDATE "relay_steering_messages" SET "idempotency_key" = 'relay:legacy:' || "kin
 CREATE UNIQUE INDEX "uq_relay_steering_messages_idempotency" ON "relay_steering_messages" ("tenant_id", "execution_id", "idempotency_key");
 `;
 
+// ../../migrations/sqlite/0019_event_history_binding.sql
+var _0019_event_history_binding_default = `CREATE TABLE "relay_event_history_bindings" (
+  "binding_key" integer PRIMARY KEY NOT NULL,
+  "store_identity" text NOT NULL,
+  "state" text NOT NULL,
+  CONSTRAINT "ck_relay_event_history_bindings_singleton" CHECK ("binding_key" = 1),
+  CONSTRAINT "ck_relay_event_history_bindings_identity" CHECK (length("store_identity") = 64),
+  CONSTRAINT "ck_relay_event_history_bindings_state" CHECK ("state" IN ('allocating', 'publishing', 'ready'))
+);
+`;
+
 // src/sqlite-migrations.ts
 import { Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
@@ -817,7 +833,8 @@ var migrations = [
     file: "0017_execution_event_identity_directory.sql",
     source: _0017_execution_event_identity_directory_default
   },
-  { id: 18, name: "idempotent_steering", file: "0018_idempotent_steering.sql", source: _0018_idempotent_steering_default }
+  { id: 18, name: "idempotent_steering", file: "0018_idempotent_steering.sql", source: _0018_idempotent_steering_default },
+  { id: 19, name: "event_history_binding", file: "0019_event_history_binding.sql", source: _0019_event_history_binding_default }
 ];
 var loader = Effect.succeed(migrations.map(({ id, name, source }) => [id, name, Effect.succeed(execute(source))]));
 
@@ -831,15 +848,41 @@ var canonicalFilename = Effect2.fn("SQLite.canonicalFilename")(function* (filena
   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 databaseConfigurationFailure = () => RuntimeConfigurationError.make({
+  category: "database-config",
+  scope: "database-client",
+  cause: {
+    reasons: [
+      { _tag: "Fail", category: "database-config", errorTag: "RuntimeHostLayerFailure" }
+    ],
+    truncated: false
+  }
+});
+var eventHistoryOptions = (rootDirectory) => {
+  const operationGate = Semaphore.makeUnsafe(1);
+  return {
+    executionEventRepositoryLayer: exports_runtime_event_history.fileSystemRepositoryLayer({
+      rootDirectory,
+      operationGate
+    }).pipe(Layer.provide(bunServicesLayer), Layer.catchCause((cause) => Layer.unwrap(Effect2.failCause(Cause.map(cause, databaseConfigurationFailure))))),
+    eventHistoryCheck: exports_runtime_event_history.fileSystemHealth({
+      rootDirectory,
+      operationGate
+    }).pipe(Effect2.provide(bunServicesLayer), Effect2.mapError(() => RuntimeReadinessError.make({
+      phase: "event-history",
+      cause: HostUnavailable.make({ host: "event-history", reason: "health check failed" })
+    })))
+  };
+};
 var database2 = (options) => {
-  if (options.filename.length === 0) {
-    const failure = RuntimeConfigurationError.make({
-      category: "database-config",
-      scope: "database-client",
-      cause: {
-        reasons: [{ _tag: "Fail", category: "database-config", errorTag: "RuntimeHostLayerFailure" }],
-        truncated: false
-      }
+  if (options.eventHistory !== undefined && options.filename === ":memory:") {
+    const failure = RuntimeTopologyError.make({
+      dialect: "sqlite",
+      role: "embedded",
+      nextAction: "use-different-database",
+      cause: UnsupportedTopology.make({
+        reason: "Filesystem event history requires persistent SQLite and a directory"
+      })
     });
     return make({
       dialect: "sqlite",
@@ -848,14 +891,25 @@ var database2 = (options) => {
       runtimeLayer: Layer.unwrap(Effect2.fail(failure))
     });
   }
+  if (options.filename.length === 0 || options.eventHistory !== undefined && (options.eventHistory._tag !== "FileSystem" || options.eventHistory.directory.length === 0)) {
+    const failure = databaseConfigurationFailure();
+    return make({
+      dialect: "sqlite",
+      migrate: Effect2.fail(failure),
+      verify: Effect2.fail(failure),
+      runtimeLayer: Layer.unwrap(Effect2.fail(failure))
+    });
+  }
   const memoryOwnerIdentity = options.filename === ":memory:" ? `sqlite:memory:${memoryIdentity++}` : undefined;
+  const historyRoot = options.eventHistory === undefined ? undefined : resolve(options.eventHistory.directory);
   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 resolveDatabase = resolvedFilename.pipe(Effect2.map((filename) => makeSqliteDatabase(options, filename, memoryOwnerIdentity)));
   return make({
     dialect: "sqlite",
     runtimeLayer: Layer.unwrap(resolveDatabase.pipe(Effect2.map(runtimeLayer))),
     migrate: resolveDatabase.pipe(Effect2.flatMap((value) => value.migrate)),
-    verify: resolveDatabase.pipe(Effect2.flatMap((value) => value.verify))
+    verify: resolveDatabase.pipe(Effect2.flatMap((value) => value.verify)),
+    ...historyRoot === undefined ? {} : eventHistoryOptions(historyRoot)
   });
 };
 var makeSqliteDatabase = (options, filename, memoryOwnerIdentity) => {
@@ -876,9 +930,10 @@ var makeSqliteDatabase = (options, filename, memoryOwnerIdentity) => {
       });
     }
   });
+  const { eventHistory: _eventHistory, ...clientOptions } = options;
   const adapterDatabase = database({
     dialect: "sqlite",
-    clientLayer: clientLayer({ ...options, filename }),
+    clientLayer: clientLayer({ ...clientOptions, filename }),
     databaseIdentity,
     ownership: "runtime-exclusive",
     schemaHead: String(migrations.at(-1)?.id ?? 0),

package/dist/types/relay/event-history.d.ts

@@ -0,0 +1,8 @@
+export interface FileSystemConfig {
+    readonly _tag: "FileSystem";
+    readonly directory: string;
+}
+export type Config = FileSystemConfig;
+export declare const fileSystem: (options: {
+    readonly directory: string;
+}) => FileSystemConfig;

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

@@ -4,6 +4,7 @@ import * as CommandModule from "./command";
 import * as OperationModule from "./operation";
 import * as ToolWorkerModule from "./tool-worker";
 import * as RuntimeModule from "./runtime";
+import * as EventHistoryModule from "./event-history";
 import * as WorkflowDefinitionHostModule from "./workflow-definition-host";
 import { DatabaseIdentity, makeDatabaseIdentity } from "./database-identity";
 import { Address, Agent, ChildOrchestration, Content, Resident, Envelope, Execution, Ids, Inbox, Pagination, Presence, Schedule, Shared, Skill, State, Tool, Waits, Workflow } from "../schema/index";
@@ -23,6 +24,7 @@ export import Command = CommandModule;
 export import Operation = OperationModule;
 export import ToolWorker = ToolWorkerModule;
 export import Runtime = RuntimeModule;
+export import EventHistory = EventHistoryModule;
 export import WorkflowDefinitionHost = WorkflowDefinitionHostModule;
 export import ArtifactStore = ArtifactStoreModule;
 export import BlobStore = BlobStoreModule;

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

@@ -1 +1 @@
-export declare const migrations: readonly [readonly [1, "baseline", string], readonly [2, "durable_tool_placement", string], readonly [3, "durable_inbox", string], readonly [4, "execution_state", string], readonly [5, "durable_entities", string], readonly [6, "ephemeral_presence", string], readonly [7, "topic_subscriptions", string], readonly [8, "child_fan_out", string], readonly [9, "workflow_definitions", string], readonly [10, "workflow_runtime", string], readonly [11, "execution_scoped_tool_calls", string], readonly [12, "rename_entity_to_resident", string], readonly [13, "steering_delivered", string], readonly [14, "session_writer_ownership", string], readonly [15, "transactional_event_head", string], readonly [16, "execution_event_archive_manifests", string], readonly [17, "execution_event_identity_directory", string], readonly [18, "idempotent_steering", string]];
+export declare const migrations: readonly [readonly [1, "baseline", string], readonly [2, "durable_tool_placement", string], readonly [3, "durable_inbox", string], readonly [4, "execution_state", string], readonly [5, "durable_entities", string], readonly [6, "ephemeral_presence", string], readonly [7, "topic_subscriptions", string], readonly [8, "child_fan_out", string], readonly [9, "workflow_definitions", string], readonly [10, "workflow_runtime", string], readonly [11, "execution_scoped_tool_calls", string], readonly [12, "rename_entity_to_resident", string], readonly [13, "steering_delivered", string], readonly [14, "session_writer_ownership", string], readonly [15, "transactional_event_head", string], readonly [16, "execution_event_archive_manifests", string], readonly [17, "execution_event_identity_directory", string], readonly [18, "idempotent_steering", string], readonly [19, "event_history_binding", string]];

package/dist/types/relay/runtime-database-owner.d.ts

@@ -1,13 +1,19 @@
 import { Effect, Layer } from "effect";
-import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import { type SqlClient } from "effect/unstable/sql/SqlClient";
 import type { Service as RuntimeDatabaseService } from "./runtime-database";
 import type { Dialect } from "./runtime";
 import type { Database } from "./runtime-database-public";
+import type { ExecutionEventRepository, NotificationBus } from "../store-sql/portable";
+import type { RuntimeReadinessError } from "./runtime";
 import { RuntimeConfigurationError } from "./runtime-acquisition-error";
 export declare const make: <D extends Dialect, E, R>(value: {
     readonly dialect: D;
     readonly migrate: Effect.Effect<void, E, R>;
     readonly verify: Effect.Effect<void, E, R>;
     readonly runtimeLayer: Layer.Layer<RuntimeDatabaseService | SqlClient, E, R>;
+    readonly executionEventRepositoryLayer?: Layer.Layer<ExecutionEventRepository.Service, RuntimeConfigurationError, NotificationBus.Service | SqlClient>;
+    readonly eventHistoryCheck?: Effect.Effect<void, RuntimeReadinessError, SqlClient>;
 }) => Database<D, E, R>;
+export declare const executionEventRepositoryLayer: <D extends Dialect, E, R>(database: Database<D, E, R>) => Layer.Layer<ExecutionEventRepository.Service, RuntimeConfigurationError, NotificationBus.Service | SqlClient> | undefined;
+export declare const eventHistoryCheck: <D extends Dialect, E, R>(database: Database<D, E, R>) => Effect.Effect<void, RuntimeReadinessError, SqlClient> | undefined;
 export declare const runtimeLayer: <D extends Dialect, E, R>(database: Database<D, E, R>) => Layer.Layer<RuntimeDatabaseService | SqlClient, E | RuntimeConfigurationError, R>;

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

@@ -99,7 +99,7 @@ declare const RuntimeMigrationError_base: Schema.Class<RuntimeMigrationError, Sc
 export declare class RuntimeMigrationError extends RuntimeMigrationError_base {
 }
 declare const RuntimeReadinessError_base: Schema.Class<RuntimeReadinessError, Schema.TaggedStruct<"RuntimeReadinessError", {
-    readonly phase: Schema.Literals<readonly ["database", "notification", "cluster", "hosts"]>;
+    readonly phase: Schema.Literals<readonly ["database", "notification", "cluster", "hosts", "event-history"]>;
     readonly cause: Schema.Schema<RuntimeReadinessCause>;
 }>, Cause.YieldableError>;
 export declare class RuntimeReadinessError extends RuntimeReadinessError_base {
@@ -122,6 +122,10 @@ export declare const ReadinessStatus: Schema.Struct<{
     readonly databaseIdentity: Schema.brand<Schema.NonEmptyString, "@relayfx/sdk/DatabaseIdentity">;
     readonly schemaHead: Schema.String;
     readonly notification: Schema.Literals<readonly ["pg-listen-notify", "polling", "in-process"]>;
+    readonly eventHistory: Schema.Struct<{
+        readonly mode: Schema.Literals<readonly ["sql-only", "archive-aware"]>;
+        readonly health: Schema.Literal<"healthy">;
+    }>;
     readonly capabilities: Schema.Struct<{
         readonly fanOut: Schema.Union<readonly [Schema.Struct<{
             readonly enabled: Schema.Literal<false>;

package/dist/types/relay/sqlite-migrations.d.ts

@@ -90,5 +90,10 @@ export declare const migrations: readonly [{
     readonly name: "idempotent_steering";
     readonly file: "0018_idempotent_steering.sql";
     readonly source: string;
+}, {
+    readonly id: 19;
+    readonly name: "event_history_binding";
+    readonly file: "0019_event_history_binding.sql";
+    readonly source: string;
 }];
-export declare const loader: Effect.Effect<(readonly [1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18, "baseline" | "child_fan_out" | "durable_entities" | "durable_inbox" | "durable_tool_placement" | "ephemeral_presence" | "execution_event_archive_manifests" | "execution_event_identity_directory" | "execution_scoped_tool_calls" | "execution_state" | "idempotent_steering" | "rename_entity_to_resident" | "session_writer_ownership" | "steering_delivered" | "topic_subscriptions" | "transactional_event_head" | "workflow_definitions" | "workflow_runtime", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;
+export declare const loader: Effect.Effect<(readonly [1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19, "baseline" | "child_fan_out" | "durable_entities" | "durable_inbox" | "durable_tool_placement" | "ephemeral_presence" | "event_history_binding" | "execution_event_archive_manifests" | "execution_event_identity_directory" | "execution_scoped_tool_calls" | "execution_state" | "idempotent_steering" | "rename_entity_to_resident" | "session_writer_ownership" | "steering_delivered" | "topic_subscriptions" | "transactional_event_head" | "workflow_definitions" | "workflow_runtime", Effect.Effect<Effect.Effect<void, import("effect/unstable/sql/SqlError").SqlError, SqlClient>, never, never>])[], never, never>;

package/dist/types/relay/sqlite-runtime.d.ts

@@ -2,6 +2,7 @@ import type { Database } from "./runtime-database-public";
 import { RuntimeConfigurationError, RuntimeMigrationError, RuntimeTopologyError } from "./runtime";
 interface SQLiteRuntimeDatabaseOptions {
     readonly filename: string;
+    readonly eventHistory?: import("./event-history").Config;
     readonly disableWAL?: boolean;
     readonly spanAttributes?: Record<string, unknown>;
     readonly transformResultNames?: (name: string) => string;

package/dist/types/relay/tool-runtime.d.ts

@@ -1,8 +1,15 @@
 export * from "../runtime/tool/tool-runtime-contract";
-import type { DynamicToolOptions, Interface, PlacedToolOptions, RegisteredTool, RunError, RunInput, Service, ToolkitRegistrationOptions, ToolOptions } from "../runtime/tool/tool-runtime-contract";
+import type { DynamicToolOptions, Interface, PlacedToolOptions, RegisteredTool, RunError, RunInput, Service, ToolkitRegistrationOptions, ToolExecutionContext, ToolExecutionFailed, ToolOptions } from "../runtime/tool/tool-runtime-contract";
 import { Context, Effect, Layer, Schema } from "effect";
 import type { Tool as AiTool, Toolkit } from "effect/unstable/ai";
 import type { Tool } from "../schema/index";
+export interface ToolkitInvocationContext<Services, Requirements> {
+    readonly make: (context: ToolExecutionContext) => Effect.Effect<Context.Context<Services>, ToolExecutionFailed, Requirements>;
+}
+export interface HandledToolkitRegistrationOptions<Services = never, Requirements = never> {
+    readonly tools?: ToolkitRegistrationOptions;
+    readonly invocation?: ToolkitInvocationContext<Services, Requirements>;
+}
 export declare const tool: {
     <const Name extends string, Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(name: Name, options: ToolOptions<Input, Output>): RegisteredTool;
     <Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(options: ToolOptions<Input, Output>): <const Name extends string>(name: Name) => RegisteredTool;
@@ -40,5 +47,11 @@ export declare const layerFromToolkit: {
     <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<HostService, never, AiTool.HandlersFor<Tools>>;
     (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<HostService, never, AiTool.HandlersFor<Tools>>;
 };
+export declare const layerFromHandledToolkit: {
+    <Tools extends Record<string, AiTool.Any>, E, R>(toolkit: Effect.Effect<Toolkit.WithHandler<Tools>, E, R>): Layer.Layer<HostService, E, R>;
+    <Tools extends Record<string, AiTool.Any>, E, R, InvocationRequirements>(toolkit: Effect.Effect<Toolkit.WithHandler<Tools>, E, R>, options: HandledToolkitRegistrationOptions<AiTool.HandlerServices<Tools[keyof Tools]>, InvocationRequirements>): Layer.Layer<HostService, E, R | InvocationRequirements>;
+    (): <Tools extends Record<string, AiTool.Any>, E, R>(toolkit: Effect.Effect<Toolkit.WithHandler<Tools>, E, R>) => Layer.Layer<HostService, E, R>;
+    <Services, InvocationRequirements>(options: HandledToolkitRegistrationOptions<Services, InvocationRequirements>): <Tools extends Record<string, AiTool.Any>, E, R>(toolkit: Effect.Effect<Toolkit.WithHandler<Tools>, E, R>) => Layer.Layer<HostService, E, R | InvocationRequirements>;
+};
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
 export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, RunError, Service>;