@relayfx/sdk 0.3.1 → 0.3.3

package/dist/index.js

@@ -1,68 +1,49 @@
 // @bun
 import {
-  exports_language_model_registration
-} from "./index-d3dme13d.js";
-import {
-  Service,
-  exports_client,
-  exports_command,
-  exports_operation,
+  DatabaseIdentity,
+  exports_artifact_store_service,
+  exports_blob_store_service,
+  exports_child_fan_out_host,
+  exports_embedding_model_service,
+  exports_language_model_service,
+  exports_model_hub,
+  exports_prompt_assembler_service,
   exports_runtime,
+  exports_schema_registry_service,
+  exports_tool_runtime,
+  exports_workflow_definition_host,
   makeDatabaseIdentity
-} from "./index-9k4k3wq1.js";
+} from "./index-8pa5e2yn.js";
 import {
-  Dialect,
-  __export,
-  decodeBool,
-  decodeJson,
-  dialect,
-  encodeJson,
-  exports_activity_version_registry,
-  exports_address_book_service,
-  exports_address_resolution_service,
+  exports_model_registry
+} from "./index-25gwk9tj.js";
+import {
+  Service,
   exports_address_schema,
-  exports_agent_loop_service,
-  exports_agent_registry_service,
   exports_agent_schema,
-  exports_artifact_store_service,
-  exports_blob_store_service,
-  exports_child_fan_out_runtime,
-  exports_child_run_service,
+  exports_child_orchestration_schema,
+  exports_client_public,
+  exports_command,
   exports_content_schema,
-  exports_definition_runtime,
-  exports_embedding_model_service,
   exports_entity_schema,
   exports_envelope_schema,
-  exports_envelope_service,
-  exports_event_log_service,
-  exports_execution_entity,
   exports_execution_schema,
-  exports_execution_service,
-  exports_execution_workflow,
   exports_ids_schema,
-  exports_language_model_service,
-  exports_model_call_policy,
+  exports_inbox_schema,
+  exports_operation,
+  exports_pagination_schema,
   exports_presence_schema,
-  exports_presence_service,
-  exports_presence_tool,
-  exports_prompt_assembler_service,
-  exports_runner_runtime_service,
   exports_schedule_schema,
-  exports_scheduler_service,
-  exports_schema_registry_service,
   exports_shared_schema,
-  exports_skill_definition_repository,
-  exports_skill_registry_service,
   exports_skill_schema,
-  exports_tool_runtime_service,
+  exports_state_schema,
   exports_tool_schema,
   exports_wait_schema,
-  exports_wait_service,
-  exports_workflow_schema,
-  fromDbTimestamp,
-  fromNullableDbTimestamp,
-  timestampParam
-} from "./index-c2skef55.js";
+  exports_workflow_schema
+} from "./index-cphmds30.js";
+import {
+  __export
+} from "./index-nb39b5ae.js";
 
 // src/adapter-outbox.ts
 var exports_adapter_outbox = {};
@@ -112,778 +93,26 @@ var submitInbound = Effect.fn("AdapterOutbox.submitInbound.call")(function* (inp
   const service = yield* Service2;
   return yield* service.submitInbound(input);
 });
-// src/database.ts
-var exports_database = {};
-__export(exports_database, {
-  testLayer: () => testLayer3,
-  pgTypeParsers: () => pgTypeParsers2,
-  layerFromPgClient: () => layerFromPgClient2,
-  dialect: () => dialect2,
-  check: () => check2,
-  Service: () => Service4,
-  PgClientLive: () => PgClientLive2,
-  Dialect: () => Dialect2
-});
-// ../store-sql/src/database/database-service.ts
-var exports_database_service = {};
-__export(exports_database_service, {
-  timestampParam: () => timestampParam,
-  testLayer: () => testLayer2,
-  pgTypeParsers: () => pgTypeParsers,
-  layerFromPgClient: () => layerFromPgClient,
-  layer: () => layer2,
-  fromPgDate: () => fromDbTimestamp,
-  fromNullablePgDate: () => fromNullableDbTimestamp,
-  fromNullableDbTimestamp: () => fromNullableDbTimestamp,
-  fromDbTimestamp: () => fromDbTimestamp,
-  encodeJson: () => encodeJson,
-  dialect: () => dialect,
-  decodeJson: () => decodeJson,
-  decodeBool: () => decodeBool,
-  check: () => check,
-  Service: () => Service3,
-  PgClientLive: () => PgClientLive,
-  Dialect: () => Dialect
-});
-import { layerConfig as PgClientLayerConfig } from "@effect/sql-pg/PgClient";
-import { makeWithDefaults } from "drizzle-orm/effect-postgres";
-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/database-service/Service") {
-}
-var pgTypeParsers = {
-  getTypeParser: (typeId, format) => {
-    if ([1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182].includes(typeId)) {
-      return (value) => value;
-    }
-    return types.getTypeParser(typeId, format);
-  }
-};
-var PgClientLive = PgClientLayerConfig({
-  url: Config.redacted("DATABASE_URL").pipe(Config.withDefault(Redacted.make("postgres://relay:relay@localhost:5545/relay"))),
-  maxConnections: Config.int("RELAY_SQL_MAX_CONNECTIONS").pipe(Config.withDefault(8)),
-  applicationName: Config.string("RELAY_SQL_APPLICATION_NAME").pipe(Config.withDefault("relay")),
-  types: Config.succeed(pgTypeParsers)
-});
-var layerFromPgClient = Layer2.effect(Service3, makeWithDefaults());
-var layer2 = layerFromPgClient.pipe(Layer2.provide(PgClientLive));
-var testLayer2 = (db) => Layer2.succeed(Service3, db);
-var check = Effect2.fn("Database.check")(function* () {
-  const db = yield* Service3;
-  yield* db.execute(sql`select 1 as ok`).pipe(Effect2.asVoid);
-});
-// ../store-sql/src/schema/relay-schema.ts
-var exports_relay_schema = {};
-__export(exports_relay_schema, {
-  relayWorkspaceSnapshots: () => relayWorkspaceSnapshots,
-  relayWorkspaceLeases: () => relayWorkspaceLeases,
-  relayWorkflowRuns: () => relayWorkflowRuns,
-  relayWorkflowOperationStates: () => relayWorkflowOperationStates,
-  relayWorkflowLifecycleEvents: () => relayWorkflowLifecycleEvents,
-  relayWorkflowDefinitionRevisions: () => relayWorkflowDefinitionRevisions,
-  relayWaits: () => relayWaits,
-  relayTopicSubscriptions: () => relayTopicSubscriptions,
-  relayToolResults: () => relayToolResults,
-  relayToolCalls: () => relayToolCalls,
-  relayToolAttempts: () => relayToolAttempts,
-  relaySteeringMessages: () => relaySteeringMessages,
-  relaySteeringDrains: () => relaySteeringDrains,
-  relaySkillDefinitions: () => relaySkillDefinitions,
-  relaySkillDefinitionRevisions: () => relaySkillDefinitionRevisions,
-  relaySessions: () => relaySessions,
-  relaySessionEntries: () => relaySessionEntries,
-  relaySchedules: () => relaySchedules,
-  relayRouteAttempts: () => relayRouteAttempts,
-  relayPresence: () => relayPresence,
-  relayPermissionRules: () => relayPermissionRules,
-  relayMemoryRecords: () => relayMemoryRecords,
-  relayInboxMessages: () => relayInboxMessages,
-  relayInboxDrains: () => relayInboxDrains,
-  relayIdempotencyKeys: () => relayIdempotencyKeys,
-  relayExecutions: () => relayExecutions,
-  relayExecutionStateOps: () => relayExecutionStateOps,
-  relayExecutionState: () => relayExecutionState,
-  relayExecutionSkillPins: () => relayExecutionSkillPins,
-  relayExecutionEvents: () => relayExecutionEvents,
-  relayExecutionContextEpochs: () => relayExecutionContextEpochs,
-  relayEnvelopes: () => relayEnvelopes,
-  relayEnvelopeReady: () => relayEnvelopeReady,
-  relayEntityKinds: () => relayEntityKinds,
-  relayEntityInstances: () => relayEntityInstances,
-  relayChildFanOuts: () => relayChildFanOuts,
-  relayChildFanOutMembers: () => relayChildFanOutMembers,
-  relayChildExecutions: () => relayChildExecutions,
-  relayAgentDefinitions: () => relayAgentDefinitions,
-  relayAgentDefinitionRevisions: () => relayAgentDefinitionRevisions,
-  relayAgentCompactions: () => relayAgentCompactions,
-  relayAgentChats: () => relayAgentChats,
-  relayAddressBookEntries: () => relayAddressBookEntries
-});
-import {
-  boolean,
-  doublePrecision,
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  primaryKey,
-  text,
-  timestamp,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-import { sql as sql2 } from "drizzle-orm";
-var tenantId = () => text("tenant_id").$type().notNull().default(exports_ids_schema.SystemTenantId);
-var relayWorkflowDefinitionRevisions = pgTable("relay_workflow_definition_revisions", {
-  tenantId: tenantId(),
-  workflowDefinitionId: text("workflow_definition_id").$type().notNull(),
-  revision: integer("revision").$type().notNull(),
-  digest: text("digest").$type().notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.workflowDefinitionId, table.revision] }),
-  uniqueIndex("uq_relay_workflow_definition_digest").on(table.tenantId, table.workflowDefinitionId, table.digest)
-]);
-var relayWorkflowRuns = pgTable("relay_workflow_runs", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  workflowDefinitionId: text("workflow_definition_id").$type().notNull(),
-  workflowDefinitionRevision: integer("workflow_definition_revision").$type().notNull(),
-  workflowDefinitionDigest: text("workflow_definition_digest").$type().notNull(),
-  status: text("status").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId] })]);
-var relayWorkflowOperationStates = pgTable("relay_workflow_operation_states", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  operationId: text("operation_id").$type().notNull(),
-  status: text("status").notNull(),
-  fanOutId: text("fan_out_id"),
-  decision: boolean("decision"),
-  outputJson: jsonb("output_json"),
-  attempt: integer("attempt"),
-  backoffUntil: timestamp("backoff_until", { withTimezone: true }),
-  compensationOperationId: text("compensation_operation_id"),
-  startedAt: timestamp("started_at", { withTimezone: true }),
-  completedAt: timestamp("completed_at", { withTimezone: true }),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId, table.operationId] })]);
-var relayWorkflowLifecycleEvents = pgTable("relay_workflow_lifecycle_events", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  sequence: integer("sequence").notNull(),
-  eventType: text("event_type").notNull(),
-  operationId: text("operation_id"),
-  dataJson: jsonb("data_json"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId, table.sequence] })]);
-var relayEntityKinds = pgTable("relay_entity_kinds", {
-  tenantId: tenantId(),
-  kind: text("kind").$type().notNull(),
-  agentId: text("agent_id").$type().notNull(),
-  inboxPolicyJson: jsonb("inbox_policy_json").$type(),
-  stateEnabled: integer("state_enabled").$type(),
-  continueAsNewAfterTurns: integer("continue_as_new_after_turns"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.kind], name: "pk_relay_entity_kinds" })]);
-var relayEntityInstances = pgTable("relay_entity_instances", {
-  tenantId: tenantId(),
-  kind: text("kind").$type().notNull(),
-  key: text("key").$type().notNull(),
-  addressId: text("address_id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  generation: integer("generation").notNull(),
-  status: text("status").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  destroyedAt: timestamp("destroyed_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.kind, table.key], name: "pk_relay_entity_instances" }),
-  index("idx_relay_entity_instances_kind_status").on(table.tenantId, table.kind, table.status)
-]);
-var relayAddressBookEntries = pgTable("relay_address_book_entries", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  addressId: text("address_id").$type().notNull(),
-  routeKind: text("route_kind").notNull(),
-  routeKey: text("route_key").notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_address_book_entries" }),
-  uniqueIndex("uq_relay_address_book_address").on(table.tenantId, table.addressId)
-]);
-var relayAgentDefinitions = pgTable("relay_agent_definitions", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  name: text("name").notNull(),
-  currentRevision: integer("current_revision").$type().notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_agent_definitions" }),
-  index("idx_relay_agent_definitions_name").on(table.tenantId, table.name)
-]);
-var relayAgentDefinitionRevisions = pgTable("relay_agent_revisions", {
-  tenantId: tenantId(),
-  agentId: text("agent_id").$type().notNull(),
-  revision: integer("revision").$type().notNull(),
-  name: text("name").notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  toolInputSchemaDigestsJson: jsonb("tool_input_schema_digests_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.agentId, table.revision],
-    name: "pk_relay_agent_revisions"
-  }),
-  index("idx_relay_agent_revisions_definition").on(table.tenantId, table.agentId, table.revision)
-]);
-var relaySkillDefinitions = pgTable("relay_skill_definitions", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  name: text("name").notNull(),
-  currentRevision: integer("current_revision").$type().notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_skill_definitions" }),
-  index("idx_relay_skill_definitions_name").on(table.tenantId, table.name)
-]);
-var relaySkillDefinitionRevisions = pgTable("relay_skill_definition_revisions", {
-  tenantId: tenantId(),
-  skillDefinitionId: text("skill_definition_id").notNull().$type(),
-  revision: integer("revision").notNull().$type(),
-  name: text("name").notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.skillDefinitionId, table.revision],
-    name: "pk_relay_skill_definition_revisions"
-  }),
-  index("idx_relay_skill_definition_revisions_definition").on(table.tenantId, table.skillDefinitionId, table.revision)
-]);
-var relayExecutionSkillPins = pgTable("relay_execution_skill_pins", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").notNull().$type(),
-  skillDefinitionId: text("skill_definition_id").notNull().$type(),
-  skillDefinitionRevision: integer("skill_definition_revision").notNull().$type(),
-  skillDefinitionSnapshotJson: jsonb("skill_definition_snapshot_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.skillDefinitionId],
-    name: "pk_relay_execution_skill_pins"
-  }),
-  index("idx_relay_execution_skill_pins_execution").on(table.tenantId, table.executionId)
-]);
-var relayAgentChats = pgTable("relay_agent_chats", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  exportJson: jsonb("export_json").notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_agent_chats" })]);
-var relayExecutionState = pgTable("relay_execution_state", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  key: text("state_key").notNull(),
-  valueJson: jsonb("value_json").$type().notNull(),
-  version: integer("version").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.executionId, table.key], name: "pk_relay_execution_state" })
-]);
-var relayExecutionStateOps = pgTable("relay_execution_state_ops", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  idempotencyKey: text("idempotency_key").notNull(),
-  key: text("state_key").notNull(),
-  version: integer("version").notNull(),
-  op: text("op").notNull(),
-  resultPresent: boolean("result_present").notNull(),
-  resultValueJson: jsonb("result_value_json").$type(),
-  resultCreatedAt: timestamp("result_created_at", { withTimezone: true }),
-  resultUpdatedAt: timestamp("result_updated_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.idempotencyKey],
-    name: "pk_relay_execution_state_ops"
-  }),
-  index("idx_relay_execution_state_ops_version").on(table.tenantId, table.executionId, table.key, table.version)
-]);
-var relayAgentCompactions = pgTable("relay_agent_compactions", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").notNull().$type(),
-  checkpointId: text("checkpoint_id").notNull(),
-  summary: text("summary").notNull(),
-  firstKeptEntryId: text("first_kept_entry_id").$type().notNull(),
-  turn: integer("turn").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.checkpointId],
-    name: "pk_relay_agent_compactions"
-  }),
-  index("idx_relay_agent_compactions_execution_turn").on(table.tenantId, table.executionId, table.turn)
-]);
-var relayMemoryRecords = pgTable("relay_memory_records", {
-  tenantId: tenantId(),
-  id: text("id").notNull(),
-  agent: text("agent").notNull(),
-  subject: text("subject").$type().notNull(),
-  embedding: doublePrecision("embedding").array().notNull(),
-  partsJson: jsonb("parts_json").$type().notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_memory_records" }),
-  index("idx_relay_memory_records_agent_subject").on(table.tenantId, table.agent, table.subject)
-]);
-var relayPermissionRules = pgTable("relay_permission_rules", {
-  tenantId: tenantId(),
-  agent: text("agent").notNull(),
-  scope: text("scope").notNull(),
-  pattern: text("pattern").notNull(),
-  ruleJson: jsonb("rule_json").$type().notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.agent, table.scope, table.pattern],
-    name: "pk_relay_permission_rules"
-  }),
-  index("idx_relay_permission_rules_agent_scope").on(table.tenantId, table.agent, table.scope)
-]);
-var relaySteeringMessages = pgTable("relay_steering_messages", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").notNull(),
-  kind: text("kind").notNull(),
-  sequence: integer("sequence").notNull(),
-  contentJson: jsonb("content_json").$type().notNull(),
-  drainId: text("drain_id"),
-  consumedAt: timestamp("consumed_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.kind, table.sequence],
-    name: "pk_relay_steering_messages"
-  }),
-  index("idx_relay_steering_messages_unconsumed").on(table.tenantId, table.executionId, table.kind, table.consumedAt, table.sequence),
-  index("idx_relay_steering_messages_drain").on(table.tenantId, table.executionId, table.kind, table.drainId, table.sequence)
-]);
-var relaySteeringDrains = pgTable("relay_steering_drains", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").notNull(),
-  kind: text("kind").notNull(),
-  drainId: text("drain_id").notNull(),
-  messageSequencesJson: jsonb("message_sequences_json").$type().notNull().default([]),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.executionId, table.kind, table.drainId],
-    name: "pk_relay_steering_drains"
-  })
-]);
-var relayInboxMessages = pgTable("relay_inbox_messages", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  sequence: integer("sequence").notNull(),
-  fromAddressId: text("from_address_id").$type().notNull(),
-  envelopeId: text("envelope_id").$type(),
-  contentJson: jsonb("content_json").$type().notNull(),
-  replyWaitId: text("reply_wait_id").$type(),
-  correlationKey: text("correlation_key"),
-  idempotencyKey: text("idempotency_key"),
-  drainId: text("drain_id"),
-  consumedAt: timestamp("consumed_at", { withTimezone: true }),
-  metadataJson: jsonb("metadata_json").$type(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.executionId, table.sequence], name: "pk_relay_inbox_messages" }),
-  uniqueIndex("uq_relay_inbox_messages_idempotency").on(table.tenantId, table.executionId, table.idempotencyKey),
-  index("idx_relay_inbox_messages_unconsumed").on(table.tenantId, table.executionId, table.consumedAt, table.sequence),
-  index("idx_relay_inbox_messages_drain").on(table.tenantId, table.executionId, table.drainId, table.sequence)
-]);
-var relayInboxDrains = pgTable("relay_inbox_drains", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  drainId: text("drain_id").notNull(),
-  messageSequencesJson: jsonb("message_sequences_json").$type().notNull().default([]),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.executionId, table.drainId], name: "pk_relay_inbox_drains" })
-]);
-var relayTopicSubscriptions = pgTable("relay_topic_subscriptions", {
-  tenantId: tenantId(),
-  topicAddressId: text("topic_address_id").$type().notNull(),
-  subscriberExecutionId: text("subscriber_execution_id").$type().notNull(),
-  metadataJson: jsonb("metadata_json").$type(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.topicAddressId, table.subscriberExecutionId],
-    name: "pk_relay_topic_subscriptions"
-  }),
-  index("idx_relay_topic_subscriptions_subscriber").on(table.tenantId, table.subscriberExecutionId)
-]);
-var relaySessions = pgTable("relay_sessions", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  rootAddressId: text("root_address_id").$type().notNull(),
-  leafEntryId: text("leaf_entry_id").$type(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_sessions" }),
-  index("idx_relay_sessions_updated_id").on(table.tenantId, table.updatedAt, table.id),
-  index("idx_relay_sessions_root_updated_id").on(table.tenantId, table.rootAddressId, table.updatedAt, table.id)
-]);
-var relaySessionEntries = pgTable("relay_session_entries", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  sessionId: text("session_id").$type().notNull(),
-  parentId: text("parent_id").$type(),
-  tag: text("tag").notNull(),
-  payloadJson: jsonb("payload_json").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_session_entries" }),
-  index("idx_relay_session_entries_session_created").on(table.tenantId, table.sessionId, table.createdAt, table.id),
-  index("idx_relay_session_entries_session_parent").on(table.tenantId, table.sessionId, table.parentId)
-]);
-var relayExecutionContextEpochs = pgTable("relay_execution_context_epochs", {
-  tenantId: tenantId(),
-  executionId: text("execution_id").$type().notNull(),
-  baseline: text("baseline").notNull(),
-  dynamicSourceIdsJson: jsonb("dynamic_source_ids_json").$type().notNull().default([]),
-  openedAt: timestamp("opened_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.executionId], name: "pk_relay_execution_context_epochs" })]);
-var relayExecutions = pgTable("relay_executions", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  rootAddressId: text("root_address_id").$type().notNull(),
-  sessionId: text("session_id").$type(),
-  status: text("status").$type().notNull(),
-  agentId: text("agent_id").$type(),
-  agentRevision: integer("agent_revision").$type(),
-  agentSnapshotJson: jsonb("agent_snapshot_json").$type(),
-  agentToolInputSchemaDigestsJson: jsonb("agent_tool_input_schema_digests_json").$type().notNull().default({}),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_executions" }),
-  index("idx_relay_executions_root_status").on(table.tenantId, table.rootAddressId, table.status),
-  index("idx_relay_executions_session_updated_id").on(table.tenantId, table.sessionId, table.updatedAt, table.id),
-  index("idx_relay_executions_updated_id").on(table.tenantId, table.updatedAt, table.id),
-  index("idx_relay_executions_root_status_updated_id").on(table.tenantId, table.rootAddressId, table.status, table.updatedAt, table.id)
-]);
-var relayChildExecutions = pgTable("relay_child_executions", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  addressId: text("address_id").$type().notNull(),
-  status: text("status").$type().notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_child_executions" }),
-  index("idx_relay_child_executions_parent").on(table.tenantId, table.executionId)
-]);
-var relayChildFanOuts = pgTable("relay_child_fan_outs", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  parentExecutionId: text("parent_execution_id").$type().notNull(),
-  definitionJson: jsonb("definition_json").$type().notNull(),
-  state: text("state").$type().notNull().default("joining"),
-  satisfiedAt: timestamp("satisfied_at", { withTimezone: true }),
-  failedAt: timestamp("failed_at", { withTimezone: true }),
-  cancelledAt: timestamp("cancelled_at", { withTimezone: true }),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_child_fan_outs" }),
-  index("idx_relay_child_fan_outs_parent").on(table.tenantId, table.parentExecutionId)
-]);
-var relayChildFanOutMembers = pgTable("relay_child_fan_out_members", {
-  tenantId: tenantId(),
-  fanOutId: text("fan_out_id").$type().notNull(),
-  childExecutionId: text("child_execution_id").$type().notNull(),
-  ordinal: integer("ordinal").notNull(),
-  state: text("state").$type().notNull().default("queued"),
-  outputJson: jsonb("output_json").$type(),
-  error: text("error"),
-  completedAt: timestamp("completed_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({
-    columns: [table.tenantId, table.fanOutId, table.childExecutionId],
-    name: "pk_relay_child_fan_out_members"
-  }),
-  uniqueIndex("uq_relay_child_fan_out_member_ordinal").on(table.tenantId, table.fanOutId, table.ordinal)
-]);
-var relayEnvelopes = pgTable("relay_envelopes", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  fromAddressId: text("from_address_id").$type().notNull(),
-  toAddressId: text("to_address_id").$type().notNull(),
-  contentJson: jsonb("content_json").$type().notNull(),
-  waitJson: jsonb("wait_json").$type(),
-  correlationKey: text("correlation_key"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelopes" }),
-  index("idx_relay_envelopes_execution").on(table.tenantId, table.executionId, table.createdAt),
-  index("idx_relay_envelopes_to_address").on(table.tenantId, table.toAddressId, table.createdAt)
-]);
-var relayWaits = pgTable("relay_waits", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  envelopeId: text("envelope_id").$type(),
-  mode: text("mode").$type().notNull(),
-  correlationKey: text("correlation_key"),
-  state: text("state").notNull().default("open"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  resolvedAt: timestamp("resolved_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_waits" }),
-  index("idx_relay_waits_execution_state").on(table.tenantId, table.executionId, table.state)
-]);
-var relayWorkspaceLeases = pgTable("relay_workspace_leases", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  providerKey: text("provider_key").$type().notNull(),
-  sandboxRef: text("sandbox_ref").$type(),
-  latestSnapshotRef: text("latest_snapshot_ref").$type(),
-  status: text("status").$type().notNull(),
-  resumeStrategy: text("resume_strategy").$type().notNull(),
-  region: text("region"),
-  requestJson: jsonb("request_json").$type(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_leases" }),
-  uniqueIndex("uq_relay_workspace_leases_active_execution").on(table.tenantId, table.executionId).where(sql2`${table.status} not in ('released', 'failed')`),
-  index("idx_relay_workspace_leases_execution").on(table.tenantId, table.executionId),
-  index("idx_relay_workspace_leases_status_updated").on(table.tenantId, table.status, table.updatedAt)
-]);
-var relayWorkspaceSnapshots = pgTable("relay_workspace_snapshots", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  leaseId: text("lease_id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  reason: text("reason").$type().notNull(),
-  snapshotRef: text("snapshot_ref").$type().notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_workspace_snapshots" }),
-  index("idx_relay_workspace_snapshots_lease").on(table.tenantId, table.leaseId, table.createdAt),
-  index("idx_relay_workspace_snapshots_execution").on(table.tenantId, table.executionId, table.createdAt)
-]);
-var relayEnvelopeReady = pgTable("relay_envelope_ready", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  envelopeId: text("envelope_id").$type().notNull(),
-  routeType: text("route_type").notNull(),
-  routeKey: text("route_key").notNull(),
-  state: text("state").notNull().default("ready"),
-  availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
-  attempt: integer("attempt").notNull().default(0),
-  claimOwner: text("claim_owner"),
-  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
-  lastError: text("last_error"),
-  idempotencyKey: text("idempotency_key"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
-  claimedAt: timestamp("claimed_at", { withTimezone: true }),
-  acknowledgedAt: timestamp("acknowledged_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_envelope_ready" }),
-  index("idx_relay_envelope_ready_state_available").on(table.tenantId, table.state, table.availableAt),
-  index("idx_relay_envelope_ready_claim_expires").on(table.tenantId, table.claimExpiresAt),
-  uniqueIndex("uq_relay_envelope_ready_idempotency").on(table.tenantId, table.idempotencyKey)
-]);
-var relaySchedules = pgTable("relay_schedules", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  kind: text("kind").notNull(),
-  targetKind: text("target_kind").notNull(),
-  addressId: text("address_id").$type(),
-  waitId: text("wait_id").$type(),
-  cronExpr: text("cron_expr"),
-  inputJson: jsonb("input_json").$type(),
-  state: text("state").notNull().default("active"),
-  nextRunAt: timestamp("next_run_at", { withTimezone: true }).notNull(),
-  attempt: integer("attempt").notNull().default(0),
-  claimOwner: text("claim_owner"),
-  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
-  lastError: text("last_error"),
-  idempotencyKey: text("idempotency_key"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_schedules" }),
-  index("idx_relay_schedules_state_next_run").on(table.tenantId, table.state, table.nextRunAt),
-  index("idx_relay_schedules_claim_expires").on(table.tenantId, table.claimExpiresAt),
-  index("idx_relay_schedules_wait").on(table.tenantId, table.waitId),
-  uniqueIndex("uq_relay_schedules_idempotency").on(table.tenantId, table.idempotencyKey)
-]);
-var relayExecutionEvents = pgTable("relay_execution_events", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  childExecutionId: text("child_execution_id").$type(),
-  type: text("type").notNull(),
-  sequence: integer("sequence").notNull(),
-  cursor: text("cursor").notNull(),
-  contentJson: jsonb("content_json").$type(),
-  dataJson: jsonb("data_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_execution_events" }),
-  index("idx_relay_execution_events_execution").on(table.tenantId, table.executionId, table.createdAt),
-  uniqueIndex("uq_relay_execution_events_sequence").on(table.tenantId, table.executionId, table.sequence),
-  uniqueIndex("uq_relay_execution_events_cursor").on(table.tenantId, table.cursor)
-]);
-var relayPresence = pgTable("relay_presence", {
-  tenantId: tenantId(),
-  id: text("id").notNull(),
-  scopeKind: text("scope_kind").$type().notNull(),
-  scopeId: text("scope_id").notNull(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  connectedAt: timestamp("connected_at", { withTimezone: true }).notNull().defaultNow(),
-  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id, table.scopeKind, table.scopeId], name: "pk_relay_presence" }),
-  index("idx_relay_presence_scope_expires").on(table.tenantId, table.scopeKind, table.scopeId, table.expiresAt)
-]);
-var relayToolCalls = pgTable("relay_tool_calls", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  executionId: text("execution_id").$type().notNull(),
-  name: text("name").notNull(),
-  inputJson: jsonb("input_json").notNull(),
-  definitionJson: jsonb("definition_json").$type(),
-  placementKind: text("placement_kind").$type().notNull().default("local"),
-  placementKey: text("placement_key"),
-  state: text("state").$type().notNull().default("requested"),
-  waitId: text("wait_id").$type(),
-  idempotencyKey: text("idempotency_key").notNull(),
-  availableAt: timestamp("available_at", { withTimezone: true }).notNull().defaultNow(),
-  activeAttemptId: text("active_attempt_id").$type(),
-  claimOwner: text("claim_owner"),
-  claimedAt: timestamp("claimed_at", { withTimezone: true }),
-  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
-  externalOutcomeJson: jsonb("external_outcome_json").$type(),
-  externalOutcomeAt: timestamp("external_outcome_at", { withTimezone: true }),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_tool_calls" }),
-  index("idx_relay_tool_calls_execution").on(table.tenantId, table.executionId, table.createdAt),
-  index("idx_relay_tool_calls_remote_claim").on(table.tenantId, table.placementKind, table.placementKey, table.state, table.availableAt, table.createdAt, table.id),
-  index("idx_relay_tool_calls_stale_claim").on(table.tenantId, table.state, table.claimExpiresAt),
-  index("idx_relay_tool_calls_client_pending").on(table.tenantId, table.placementKind, table.state, table.createdAt, table.id)
-]);
-var relayToolAttempts = pgTable("relay_tool_attempts", {
-  tenantId: tenantId(),
-  id: text("id").$type().notNull(),
-  toolCallId: text("tool_call_id").$type().notNull(),
-  attemptNumber: integer("attempt_number").notNull(),
-  state: text("state").$type().notNull(),
-  workerId: text("worker_id"),
-  claimExpiresAt: timestamp("claim_expires_at", { withTimezone: true }),
-  error: text("error"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  completedAt: timestamp("completed_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.toolCallId, table.id], name: "pk_relay_tool_attempts" }),
-  uniqueIndex("uq_relay_tool_attempts_number").on(table.tenantId, table.toolCallId, table.attemptNumber),
-  index("idx_relay_tool_attempts_call").on(table.tenantId, table.toolCallId, table.attemptNumber)
-]);
-var relayToolResults = pgTable("relay_tool_results", {
-  tenantId: tenantId(),
-  toolCallId: text("tool_call_id").$type().notNull(),
-  outputJson: jsonb("output_json").notNull(),
-  error: text("error"),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [primaryKey({ columns: [table.tenantId, table.toolCallId], name: "pk_relay_tool_results" })]);
-var relayRouteAttempts = pgTable("relay_route_attempts", {
-  tenantId: tenantId(),
-  id: text("id").notNull(),
-  envelopeReadyId: text("envelope_ready_id").$type().notNull(),
-  routeKey: text("route_key").notNull(),
-  state: text("state").notNull(),
-  detail: text("detail"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow()
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_route_attempts" }),
-  index("idx_relay_route_attempts_ready").on(table.tenantId, table.envelopeReadyId, table.createdAt)
-]);
-var relayIdempotencyKeys = pgTable("relay_idempotency_keys", {
-  tenantId: tenantId(),
-  id: text("id").notNull(),
-  scope: text("scope").notNull(),
-  operation: text("operation").notNull(),
-  key: text("key").notNull(),
-  resultJson: jsonb("result_json").$type(),
-  metadataJson: jsonb("metadata_json").$type().notNull().default({}),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
-  expiresAt: timestamp("expires_at", { withTimezone: true })
-}, (table) => [
-  primaryKey({ columns: [table.tenantId, table.id], name: "pk_relay_idempotency_keys" }),
-  uniqueIndex("uq_relay_idempotency_scope_operation_key").on(table.tenantId, table.scope, table.operation, table.key)
-]);
-// src/database.ts
-var Service4 = exports_database_service.Service;
-var PgClientLive2 = exports_database_service.PgClientLive;
-var layerFromPgClient2 = exports_database_service.layerFromPgClient;
-var testLayer3 = exports_database_service.testLayer;
-var check2 = exports_database_service.check;
-var pgTypeParsers2 = exports_database_service.pgTypeParsers;
-var Dialect2 = exports_database_service.Dialect;
-var dialect2 = exports_database_service.dialect;
 // src/tool-worker.ts
 var exports_tool_worker = {};
 __export(exports_tool_worker, {
   runOnce: () => runOnce,
   run: () => run
 });
-import { Clock, Duration, Effect as Effect3 } from "effect";
+import { Clock, Duration, Effect as Effect2 } from "effect";
 var failureMessage = (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error);
 var handlerOutcome = (options, lease) => {
   const handler = Object.hasOwn(options.handlers, lease.call.name) ? options.handlers[lease.call.name] : undefined;
   if (typeof handler !== "function") {
-    return Effect3.succeed({ kind: "failure", message: `No remote handler registered for ${lease.call.name}` });
+    return Effect2.succeed({ kind: "failure", message: `No remote handler registered for ${lease.call.name}` });
   }
-  return handler(lease.call.input, { lease, idempotencyKey: lease.idempotency_key }).pipe(Effect3.match({
+  return handler(lease.call.input, { lease, idempotencyKey: lease.idempotency_key }).pipe(Effect2.match({
     onFailure: (error) => ({ kind: "failure", message: failureMessage(error) }),
     onSuccess: (output) => ({ kind: "success", output })
   }));
 };
-var runOnce = Effect3.fn("ToolWorker.runOnce")(function* (options) {
+var runOnce = Effect2.fn("ToolWorker.runOnce")(function* (options) {
   const client = yield* Service;
   const now = yield* Clock.currentTimeMillis;
   const leaseMillis = Duration.toMillis(Duration.fromInputUnsafe(options.leaseDuration));
@@ -906,65 +135,307 @@ var runOnce = Effect3.fn("ToolWorker.runOnce")(function* (options) {
   });
   return true;
 });
-var run = Effect3.fn("ToolWorker.run")(function* (options) {
+var run = Effect2.fn("ToolWorker.run")(function* (options) {
   const pollInterval = Duration.fromInputUnsafe(options.pollInterval ?? "1 second");
-  return yield* runOnce(options).pipe(Effect3.flatMap((worked) => worked ? Effect3.void : Effect3.sleep(pollInterval)), Effect3.forever);
+  return yield* runOnce(options).pipe(Effect2.flatMap((worked) => worked ? Effect2.void : Effect2.sleep(pollInterval)), Effect2.forever);
+});
+
+// src/language-model-registration.ts
+var exports_language_model_registration = {};
+__export(exports_language_model_registration, {
+  withOpenRouterFetch: () => withOpenRouterFetch,
+  withOpenRouter: () => withOpenRouter,
+  withOpenAiOrDeterministicFetch: () => withOpenAiOrDeterministicFetch,
+  withOpenAiOrDeterministic: () => withOpenAiOrDeterministic,
+  withOpenAiFetch: () => withOpenAiFetch,
+  withOpenAiCompatibleFetch: () => withOpenAiCompatibleFetch,
+  withOpenAiCompatible: () => withOpenAiCompatible,
+  withOpenAiAccountFetch: () => withOpenAiAccountFetch,
+  withOpenAiAccount: () => withOpenAiAccount,
+  withOpenAi: () => withOpenAi,
+  withDeterministic: () => withDeterministic,
+  withAnthropicFetch: () => withAnthropicFetch,
+  withAnthropic: () => withAnthropic,
+  openRouterClientLayerConfig: () => openRouterClientLayerConfig,
+  openRouter: () => openRouter,
+  openAiCompatibleClientLayerConfig: () => openAiCompatibleClientLayerConfig,
+  openAiCompatible: () => openAiCompatible,
+  openAiClientLayerConfig: () => openAiClientLayerConfig,
+  openAiAccount: () => openAiAccount,
+  openAi: () => openAi,
+  deterministicModel: () => deterministicModel2,
+  anthropicClientLayerConfig: () => anthropicClientLayerConfig,
+  anthropic: () => anthropic,
+  OpenAiAccountCredentialError: () => OpenAiAccountCredentialError
 });
 
+// ../../node_modules/.bun/@batonfx+providers@0.6.1/node_modules/@batonfx/providers/dist/deterministic.js
+import { OpenAiClient as OpenAiClient2 } from "@effect/ai-openai";
+import { Config as Config2, Effect as Effect4, Layer as Layer3, Option, Stream as Stream2 } from "effect";
+import { LanguageModel, Response } from "effect/unstable/ai";
+import { FetchHttpClient as FetchHttpClient2 } from "effect/unstable/http";
+
+// ../../node_modules/.bun/@batonfx+providers@0.6.1/node_modules/@batonfx/providers/dist/openai.js
+import { OpenAiClient, OpenAiLanguageModel } from "@effect/ai-openai";
+import { Config, Effect as Effect3, Layer as Layer2, Redacted, Schema, Stream } from "effect";
+import { AiError } from "effect/unstable/ai";
+import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest } from "effect/unstable/http";
+var openAiAccountApiUrl = "https://chatgpt.com/backend-api/codex";
+var openAiAccountResponsesUrl = `${openAiAccountApiUrl}/responses`;
+var openAiAccountIdHeader = "ChatGPT-Account-ID";
+var contextOverflowCodes = new Set(["context_length_exceeded", "context_window_exceeded", "input_too_long"]);
+var classifyFailure = (error) => {
+  if (!AiError.isAiError(error))
+    return "other";
+  const reason = error.reason;
+  if (reason._tag !== "InvalidRequestError" && reason._tag !== "UnknownError")
+    return "other";
+  const metadata = reason.metadata.openai;
+  if (metadata !== null && metadata !== undefined) {
+    if (metadata.errorCode !== null && contextOverflowCodes.has(metadata.errorCode) || metadata.errorType !== null && contextOverflowCodes.has(metadata.errorType)) {
+      return "context-overflow";
+    }
+  }
+  return reason._tag === "InvalidRequestError" && /maximum context length|context length exceeded|input exceeds (?:the )?context window/i.test(reason.description ?? "") ? "context-overflow" : "other";
+};
+var openAi = (input) => exports_model_registry.registrationFromLayer({
+  provider: "openai",
+  model: input.model,
+  layer: OpenAiLanguageModel.layer({
+    model: input.model,
+    ...input.config === undefined ? {} : { config: input.config }
+  }),
+  classifyFailure,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+});
+var openAiClientLayerConfig = OpenAiClient.layerConfig;
+var withOpenAi = (options) => exports_model_registry.layerFromRegistrationEffects([openAi(options)]).pipe(Layer2.provide(OpenAiClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })));
+var withOpenAiFetch = (options) => withOpenAi(options).pipe(Layer2.provide(FetchHttpClient.layer));
+
+class OpenAiAccountCredentialError extends Schema.TaggedErrorClass()("@batonfx/providers/OpenAiAccountCredentialError", {
+  operation: Schema.Literals(["acquire", "refreshRejected"])
+}) {
+}
+var credentialFailure = (request, error) => new HttpClientError.HttpClientError({
+  reason: new HttpClientError.TransportError({
+    request,
+    cause: error,
+    description: `OpenAI account credential ${error.operation} failed`
+  })
+});
+var withCredential = (request, credential) => {
+  const body = request.body;
+  const streaming = body._tag === "Uint8Array" && body.contentType === "application/json" && new TextDecoder().decode(body.body).includes('"stream":true');
+  return request.pipe(HttpClientRequest.setUrl(openAiAccountResponsesUrl), HttpClientRequest.bearerToken(credential.accessToken), HttpClientRequest.setHeader(openAiAccountIdHeader, credential.accountId), HttpClientRequest.accept(streaming ? "text/event-stream" : "application/json"));
+};
+var executeWithCredential = (client, request, credential) => client.postprocess(Effect3.succeed(withCredential(request, credential))).pipe(Effect3.provideService(FetchHttpClient.RequestInit, { redirect: "error" }), Effect3.updateService(Headers.CurrentRedactedNames, (names) => [...names, openAiAccountIdHeader]));
+var accountClientTransform = (credentials) => (client) => HttpClient.transform(client, (_, request) => credentials.acquire.pipe(Effect3.mapError((error) => credentialFailure(request, error)), Effect3.flatMap((credential) => executeWithCredential(client, request, credential).pipe(Effect3.catchIf((error) => error.reason._tag === "StatusCodeError" && error.reason.response.status === 401, (error) => {
+  if (error.reason._tag !== "StatusCodeError")
+    return Effect3.fail(error);
+  return Stream.runDrain(error.reason.response.stream).pipe(Effect3.ignore, Effect3.andThen(credentials.refreshRejected(credential.generation)), Effect3.mapError((credentialError) => credentialFailure(request, credentialError)), Effect3.flatMap((refreshed) => executeWithCredential(client, request, refreshed)));
+})))));
+var withAccountHeaderRedaction = (effect) => effect.pipe(Effect3.updateService(Headers.CurrentRedactedNames, (names) => [...names, openAiAccountIdHeader]));
+var withoutOpenAiSocket = (effect) => effect.pipe(Effect3.provideService(OpenAiClient.OpenAiSocket, null));
+var openAiAccountClientLayer = (credentials) => Layer2.effect(OpenAiClient.OpenAiClient, OpenAiClient.make({
+  apiUrl: openAiAccountApiUrl,
+  transformClient: accountClientTransform(credentials)
+}).pipe(Effect3.map((client) => OpenAiClient.OpenAiClient.of({
+  client: client.client,
+  createResponse: (options) => withAccountHeaderRedaction(client.createResponse(options)),
+  createResponseStream: (options) => client.createResponseStream(options).pipe(withoutOpenAiSocket, withAccountHeaderRedaction, Effect3.map(([response, stream]) => [
+    response,
+    stream.pipe(Stream.updateService(Headers.CurrentRedactedNames, (names) => [...names, openAiAccountIdHeader]))
+  ])),
+  createEmbedding: (options) => withAccountHeaderRedaction(client.createEmbedding(options))
+}))));
+var openAiAccount = (input) => exports_model_registry.registrationFromLayer({
+  provider: "openai",
+  model: input.model,
+  layer: OpenAiLanguageModel.layer({
+    model: input.model,
+    ...input.config === undefined ? {} : { config: input.config }
+  }).pipe(Layer2.provide(openAiAccountClientLayer(input.credentials))),
+  classifyFailure,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+});
+var withOpenAiAccount = (input) => exports_model_registry.layerFromRegistrationEffects([openAiAccount(input)]);
+var withOpenAiAccountFetch = (input) => withOpenAiAccount(input).pipe(Layer2.provide(FetchHttpClient.layer));
+
+// ../../node_modules/.bun/@batonfx+providers@0.6.1/node_modules/@batonfx/providers/dist/deterministic.js
+var deterministicModelLayer = Layer3.effect(LanguageModel.LanguageModel, LanguageModel.make({
+  generateText: () => Effect4.succeed([{ type: "text", text: "deterministic response" }]),
+  streamText: () => Stream2.make(Response.makePart("text-delta", { id: "text", delta: "deterministic response" }))
+}));
+var deterministicModel = (input = {}) => exports_model_registry.registrationFromLayer({
+  provider: input.provider ?? "deterministic",
+  model: input.model ?? "deterministic",
+  layer: deterministicModelLayer,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+});
+var withDeterministic = (input = {}) => exports_model_registry.layerFromRegistrationEffects([deterministicModel(input)]);
+var withOpenAiOrDeterministic = (options) => Layer3.unwrap(Effect4.gen(function* () {
+  const deterministic = yield* deterministicModel({
+    provider: options.fallbackProvider ?? "deterministic",
+    model: options.fallbackModel
+  });
+  const configuredApiKey = yield* Config2.option(options.apiKey);
+  const openAiRegistration = yield* Option.match(configuredApiKey, {
+    onNone: () => Effect4.succeedNone,
+    onSome: (apiKey) => Layer3.build(OpenAiClient2.layerConfig({
+      ...options.clientConfig,
+      apiKey: Config2.succeed(apiKey)
+    })).pipe(Effect4.flatMap((context) => openAi(options).pipe(Effect4.provide(context))), Effect4.asSome)
+  });
+  return exports_model_registry.layer([
+    deterministic,
+    ...Option.isSome(openAiRegistration) ? [openAiRegistration.value] : []
+  ]);
+}));
+var withOpenAiOrDeterministicFetch = (options) => withOpenAiOrDeterministic(options).pipe(Layer3.provide(FetchHttpClient2.layer));
+
+// ../../node_modules/.bun/@batonfx+providers@0.6.1/node_modules/@batonfx/providers/dist/anthropic.js
+import { AnthropicClient, AnthropicLanguageModel } from "@effect/ai-anthropic";
+import { Config as Config3, Layer as Layer4, Redacted as Redacted2 } from "effect";
+import { AiError as AiError2 } from "effect/unstable/ai";
+import { FetchHttpClient as FetchHttpClient3 } from "effect/unstable/http";
+var classifyFailure2 = (error) => {
+  if (!AiError2.isAiError(error) || error.reason._tag !== "InvalidRequestError")
+    return "other";
+  const metadata = error.reason.metadata.anthropic;
+  return metadata?.errorType === "invalid_request_error" && /\bprompt is too long\b/i.test(error.reason.description ?? "") ? "context-overflow" : "other";
+};
+var anthropic = (input) => exports_model_registry.registrationFromLayer({
+  provider: "anthropic",
+  model: input.model,
+  layer: AnthropicLanguageModel.layer({
+    model: input.model,
+    ...input.config === undefined ? {} : { config: input.config }
+  }),
+  classifyFailure: classifyFailure2,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+});
+var anthropicClientLayerConfig = AnthropicClient.layerConfig;
+var withAnthropic = (options) => exports_model_registry.layerFromRegistrationEffects([anthropic(options)]).pipe(Layer4.provide(AnthropicClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })));
+var withAnthropicFetch = (options) => withAnthropic(options).pipe(Layer4.provide(FetchHttpClient3.layer));
+// ../../node_modules/.bun/@batonfx+providers@0.6.1/node_modules/@batonfx/providers/dist/openai-compat.js
+import { OpenAiClient as OpenAiClient3, OpenAiLanguageModel as OpenAiLanguageModel2 } from "@effect/ai-openai-compat";
+import { Config as Config4, Layer as Layer5, Redacted as Redacted3 } from "effect";
+import { FetchHttpClient as FetchHttpClient4 } from "effect/unstable/http";
+var openAiCompatible = (input) => exports_model_registry.registrationFromLayer({
+  provider: input.provider ?? "openai-compatible",
+  model: input.model,
+  layer: OpenAiLanguageModel2.layer({
+    model: input.model,
+    ...input.config === undefined ? {} : { config: input.config }
+  }),
+  ...input.classifyFailure === undefined ? {} : { classifyFailure: input.classifyFailure },
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+});
+var openAiCompatibleClientLayerConfig = OpenAiClient3.layerConfig;
+var clientLayerConfig = (options) => OpenAiClient3.layerConfig({
+  ...options.clientConfig,
+  ...options.apiKey === undefined ? {} : { apiKey: options.apiKey },
+  ...options.baseUrl === undefined ? {} : { apiUrl: Config4.succeed(options.baseUrl) }
+});
+var withOpenAiCompatible = (options) => exports_model_registry.layerFromRegistrationEffects([openAiCompatible(options)]).pipe(Layer5.provide(clientLayerConfig(options)));
+var withOpenAiCompatibleFetch = (options) => withOpenAiCompatible(options).pipe(Layer5.provide(FetchHttpClient4.layer));
+// ../../node_modules/.bun/@batonfx+providers@0.6.1/node_modules/@batonfx/providers/dist/openrouter.js
+import { OpenRouterClient, OpenRouterLanguageModel } from "@effect/ai-openrouter";
+import { Config as Config5, Layer as Layer6, Redacted as Redacted4 } from "effect";
+import { AiError as AiError3 } from "effect/unstable/ai";
+import { FetchHttpClient as FetchHttpClient5 } from "effect/unstable/http";
+var contextOverflowCodes2 = new Set(["context_length_exceeded", "context_window_exceeded", "input_too_long"]);
+var classifyFailure3 = (error) => {
+  if (!AiError3.isAiError(error))
+    return "other";
+  const reason = error.reason;
+  if (reason._tag !== "InvalidRequestError" && reason._tag !== "UnknownError")
+    return "other";
+  const metadata = reason.metadata.openrouter;
+  if (metadata !== null && metadata !== undefined) {
+    if (typeof metadata.errorCode === "string" && contextOverflowCodes2.has(metadata.errorCode) || metadata.errorType !== null && contextOverflowCodes2.has(metadata.errorType)) {
+      return "context-overflow";
+    }
+  }
+  return reason._tag === "InvalidRequestError" && /maximum context length|context length exceeded|input exceeds (?:the )?context window|prompt is too long/i.test(reason.description ?? "") ? "context-overflow" : "other";
+};
+var openRouter = (input) => exports_model_registry.registrationFromLayer({
+  provider: "openrouter",
+  model: input.model,
+  layer: OpenRouterLanguageModel.layer({
+    model: input.model,
+    ...input.config === undefined ? {} : { config: input.config }
+  }),
+  classifyFailure: classifyFailure3,
+  ...input.registrationKey === undefined ? {} : { registrationKey: input.registrationKey },
+  ...input.metadata === undefined ? {} : { metadata: input.metadata }
+});
+var openRouterClientLayerConfig = OpenRouterClient.layerConfig;
+var withOpenRouter = (options) => exports_model_registry.layerFromRegistrationEffects([openRouter(options)]).pipe(Layer6.provide(OpenRouterClient.layerConfig({ ...options.clientConfig, apiKey: options.apiKey })));
+var withOpenRouterFetch = (options) => withOpenRouter(options).pipe(Layer6.provide(FetchHttpClient5.layer));
+
+// src/language-model-registration.ts
+var deterministicModel2 = (input) => deterministicModel(input);
+
 // src/index.ts
-var relayPackage = "@relayfx/sdk";
+var AdapterOutbox = exports_adapter_outbox;
+var Client = exports_client_public;
+var ChildFanOutHost = exports_child_fan_out_host;
+var Command = exports_command;
+var Operation = exports_operation;
+var ToolWorker = exports_tool_worker;
+var Runtime = exports_runtime;
+var WorkflowDefinitionHost = exports_workflow_definition_host;
+var ArtifactStore = exports_artifact_store_service;
+var BlobStore = exports_blob_store_service;
+var EmbeddingModelService = exports_embedding_model_service;
+var LanguageModelService = exports_language_model_service;
+var ModelHub = exports_model_hub;
+var PromptAssembler = exports_prompt_assembler_service;
+var SchemaRegistry = exports_schema_registry_service;
+var ToolRuntime = exports_tool_runtime;
+var LanguageModelRegistration = exports_language_model_registration;
 export {
-  relayPackage,
   makeDatabaseIdentity,
-  exports_definition_runtime as WorkflowDefinitionRuntime,
+  WorkflowDefinitionHost,
   exports_workflow_schema as Workflow,
   exports_wait_schema as Waits,
-  exports_wait_service as WaitService,
-  exports_tool_worker as ToolWorker,
-  exports_tool_runtime_service as ToolRuntime,
+  ToolWorker,
+  ToolRuntime,
   exports_tool_schema as Tool,
-  exports_skill_registry_service as SkillRegistry,
-  exports_skill_definition_repository as SkillDefinitionRepository,
+  exports_state_schema as State,
   exports_skill_schema as Skill,
   exports_shared_schema as Shared,
-  exports_schema_registry_service as SchemaRegistry,
-  exports_scheduler_service as SchedulerService,
+  SchemaRegistry,
   exports_schedule_schema as Schedule,
-  exports_runtime as Runtime,
-  exports_runner_runtime_service as RunnerRuntime,
-  exports_relay_schema as RelaySchema,
-  exports_prompt_assembler_service as PromptAssembler,
-  exports_presence_tool as PresenceTool,
-  exports_presence_service as PresenceService,
+  Runtime,
+  PromptAssembler,
   exports_presence_schema as Presence,
-  exports_operation as Operation,
-  exports_model_call_policy as ModelCallPolicy,
-  exports_language_model_service as LanguageModelService,
-  exports_language_model_registration as LanguageModelRegistration,
+  exports_pagination_schema as Pagination,
+  Operation,
+  ModelHub,
+  LanguageModelService,
+  LanguageModelRegistration,
+  exports_inbox_schema as Inbox,
   exports_ids_schema as Ids,
-  exports_execution_workflow as ExecutionWorkflow,
-  exports_execution_service as ExecutionService,
-  exports_execution_entity as ExecutionEntity,
   exports_execution_schema as Execution,
-  exports_event_log_service as EventLog,
-  exports_envelope_service as EnvelopeService,
   exports_envelope_schema as Envelope,
   exports_entity_schema as Entity,
-  exports_embedding_model_service as EmbeddingModelService,
-  exports_database as Database,
+  EmbeddingModelService,
+  DatabaseIdentity,
   exports_content_schema as Content,
-  exports_command as Command,
-  exports_client as Client,
-  exports_child_run_service as ChildRunService,
-  exports_child_fan_out_runtime as ChildFanOutRuntime,
-  exports_blob_store_service as BlobStore,
-  exports_artifact_store_service as ArtifactStore,
-  exports_agent_registry_service as AgentRegistry,
-  exports_agent_loop_service as AgentLoop,
+  Command,
+  Client,
+  exports_child_orchestration_schema as ChildOrchestration,
+  ChildFanOutHost,
+  BlobStore,
+  ArtifactStore,
   exports_agent_schema as Agent,
-  exports_address_resolution_service as AddressResolution,
-  exports_address_book_service as AddressBook,
   exports_address_schema as Address,
-  exports_adapter_outbox as AdapterOutbox,
-  exports_activity_version_registry as ActivityVersionRegistry
+  AdapterOutbox
 };