@relayfx/sdk 0.0.49 → 0.1.0

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

@@ -1,5 +1,5 @@
 import { Agent, Ids, Shared, Tool, Workspace } from "../../schema/index";
-import { WorkspaceLeaseRepository } from "../../store-sql/index";
+import { WorkspaceLeaseRepository } from "../../store-sql/portable";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Service as EventLogService } from "../execution/event-log-service";
 import { WorkspaceCapabilityUnsupported } from "./workspace-provider-service";

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

@@ -1,8 +1,8 @@
 import { Schema } from "effect";
-export declare const RouteKind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+export declare const RouteKind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
 export type RouteKind = typeof RouteKind.Type;
 export declare const Route: Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+    readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
     readonly route_key: Schema.String;
     readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
 }>;
@@ -16,7 +16,7 @@ export declare const RouteRecord: Schema.Struct<{
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
     readonly route: Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+        readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
         readonly route_key: Schema.String;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>;
@@ -30,7 +30,7 @@ export declare const RegisterRoutePayload: Schema.Struct<{
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
     };
     readonly route: Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+        readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
         readonly route_key: Schema.String;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>;
@@ -46,7 +46,7 @@ export declare const RouteRegistered: Schema.Struct<{
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
         };
         readonly route: Schema.Struct<{
-            readonly kind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+            readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
             readonly route_key: Schema.String;
             readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         }>;
@@ -65,7 +65,7 @@ export declare const RouteList: Schema.Struct<{
             make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
         };
         readonly route: Schema.Struct<{
-            readonly kind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+            readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
             readonly route_key: Schema.String;
             readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         }>;

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

@@ -0,0 +1,40 @@
+import { Schema } from "effect";
+export declare const KindDefinition: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+    };
+    readonly inbox: Schema.optionalKey<Schema.Struct<{
+        readonly drain: Schema.Literals<readonly ["all", "one"]>;
+        readonly max_batch: Schema.optionalKey<Schema.Int>;
+    }>>;
+    readonly state_enabled: Schema.optionalKey<Schema.Boolean>;
+    readonly continue_as_new_after_turns: Schema.optionalKey<Schema.Int>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface KindDefinition extends Schema.Schema.Type<typeof KindDefinition> {
+}
+export declare const InstanceStatus: Schema.Literals<readonly ["active", "destroyed"]>;
+export type InstanceStatus = typeof InstanceStatus.Type;
+export declare const Instance: Schema.Struct<{
+    readonly kind: Schema.brand<Schema.String, "Relay.EntityKindName"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKindName">;
+    };
+    readonly key: Schema.brand<Schema.String, "Relay.EntityKey"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EntityKey">;
+    };
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly generation: Schema.Int;
+    readonly status: Schema.Literals<readonly ["active", "destroyed"]>;
+    readonly created_at: Schema.Int;
+    readonly destroyed_at: Schema.optionalKey<Schema.Int>;
+}>;
+export interface Instance extends Schema.Schema.Type<typeof Instance> {
+}

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

@@ -139,6 +139,7 @@ export declare const SendInput: Schema.Struct<{
         readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>]>>;
+    readonly idempotency_key: Schema.optionalKey<Schema.String>;
     readonly wait: Schema.optionalKey<Schema.Struct<{
         readonly mode: Schema.Literals<readonly ["reply", "event", "until", "child"]>;
         readonly timeout: Schema.optionalKey<Schema.String>;

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

@@ -276,7 +276,7 @@ export declare const ChildRunAccepted: Schema.Struct<{
 }>;
 export interface ChildRunAccepted extends Schema.Schema.Type<typeof ChildRunAccepted> {
 }
-export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+export declare const ExecutionEventType: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
 export type ExecutionEventType = typeof ExecutionEventType.Type;
 export declare const ExecutionEvent: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Relay.EventId"> & {
@@ -288,7 +288,7 @@ export declare const ExecutionEvent: Schema.Struct<{
     readonly child_execution_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
         make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
     }>;
-    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
+    readonly type: Schema.Literals<readonly ["execution.accepted", "execution.started", "execution.completed", "execution.failed", "execution.cancelled", "model.input.prepared", "model.output.delta", "model.reasoning.delta", "model.output.completed", "model.usage.reported", "budget.exceeded", "tool.call.requested", "tool.result.received", "tool.approval.requested", "tool.approval.resolved", "permission.ask.requested", "permission.ask.resolved", "steering.received", "state.updated", "state.deleted", "inbox.enqueued", "inbox.drained", "entity.created", "entity.destroyed", "envelope.accepted", "envelope.routed", "envelope.ready", "delivery.attempt", "wait.created", "wait.woken", "wait.timed_out", "wait.cancelled", "child_run.spawned", "child_run.event", "workspace.lease.planned", "workspace.lease.acquired", "workspace.suspended", "workspace.resumed", "workspace.snapshot.created", "workspace.lease.released", "workspace.lease.failed"]>;
     readonly sequence: Schema.Int;
     readonly cursor: Schema.String;
     readonly content: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{

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

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

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

@@ -0,0 +1,81 @@
+import { Schema } from "effect";
+export declare const MessageSequence: Schema.Int;
+export type MessageSequence = typeof MessageSequence.Type;
+export declare const Message: Schema.Struct<{
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly sequence: Schema.Int;
+    readonly from: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly envelope_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
+    }>;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"text">;
+        readonly text: Schema.String;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"structured">;
+        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly schema_ref: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"blob-reference">;
+        readonly uri: Schema.String;
+        readonly media_type: Schema.String;
+        readonly filename: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"artifact-reference">;
+        readonly artifact_id: Schema.String;
+        readonly media_type: Schema.optionalKey<Schema.String>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-call">;
+        readonly call: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly name: Schema.String;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"tool-result">;
+        readonly result: Schema.Struct<{
+            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+            };
+            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly error: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        }>;
+        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>]>>;
+    readonly reply_wait_id: Schema.optionalKey<Schema.brand<Schema.String, "Relay.WaitId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+    }>;
+    readonly correlation_key: Schema.optionalKey<Schema.String>;
+    readonly idempotency_key: Schema.optionalKey<Schema.String>;
+    readonly drain_id: Schema.optionalKey<Schema.String>;
+    readonly consumed_at: Schema.optionalKey<Schema.Int>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly created_at: Schema.Int;
+}>;
+export interface Message extends Schema.Schema.Type<typeof Message> {
+}
+export declare const InboxPolicy: Schema.Struct<{
+    readonly drain: Schema.Literals<readonly ["all", "one"]>;
+    readonly max_batch: Schema.optionalKey<Schema.Int>;
+}>;
+export interface InboxPolicy extends Schema.Schema.Type<typeof InboxPolicy> {
+}

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

@@ -2,11 +2,15 @@ export * as Address from "./address-schema";
 export * as Agent from "./agent-schema";
 export * as Content from "./content-schema";
 export * as Envelope from "./envelope-schema";
+export * as Entity from "./entity-schema";
 export * as Execution from "./execution-schema";
 export * as Ids from "./ids-schema";
+export * as Inbox from "./inbox-schema";
+export * as Presence from "./presence-schema";
 export * as Schedule from "./schedule-schema";
 export * as Shared from "./shared-schema";
 export * as Skill from "./skill-schema";
+export * as State from "./state-schema";
 export * as Tool from "./tool-schema";
 export * as Workspace from "./workspace-schema";
 export declare const schemaPackage = "./index";

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

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+export declare const Scope: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["execution", "session"]>;
+    readonly id: Schema.String;
+}>;
+export interface Scope extends Schema.Schema.Type<typeof Scope> {
+}
+export declare const Entry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly connected_at: Schema.Int;
+}>;
+export interface Entry extends Schema.Schema.Type<typeof Entry> {
+}
+export declare const View: Schema.Struct<{
+    readonly scope: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["execution", "session"]>;
+        readonly id: Schema.String;
+    }>;
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly connected_at: Schema.Int;
+    }>>;
+    readonly observed_at: Schema.Int;
+}>;
+export interface View extends Schema.Schema.Type<typeof View> {
+}

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

@@ -0,0 +1,35 @@
+import { Schema } from "effect";
+export declare const StateKey: Schema.String;
+export type StateKey = typeof StateKey.Type;
+export declare const StateIdempotencyKey: Schema.String;
+export type StateIdempotencyKey = typeof StateIdempotencyKey.Type;
+export declare const StateVersion: Schema.Int;
+export type StateVersion = typeof StateVersion.Type;
+export declare const StateRecordView: Schema.Struct<{
+    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+    readonly key: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly version: Schema.Int;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface StateRecordView extends Schema.Schema.Type<typeof StateRecordView> {
+}
+export declare const StateUpdatedEventData: Schema.Union<readonly [Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+    readonly blob_ref: Schema.String;
+}>]>;
+export type StateUpdatedEventData = typeof StateUpdatedEventData.Type;
+export declare const StateDeletedEventData: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly version: Schema.Int;
+}>;
+export interface StateDeletedEventData extends Schema.Schema.Type<typeof StateDeletedEventData> {
+}

package/dist/types/store-sql/address/address-book-repository.d.ts

@@ -1,7 +1,7 @@
 import { Ids, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-export declare const RouteKind: Schema.Literals<readonly ["local-agent", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+export declare const RouteKind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
 export type RouteKind = typeof RouteKind.Type;
 declare const AddressNotFound_base: Schema.Class<AddressNotFound, Schema.TaggedStruct<"AddressNotFound", {
     readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {

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

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

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

@@ -1,7 +1,9 @@
 import { Context, Effect, Layer, Stream } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 import type { SqlError } from "effect/unstable/sql/SqlError";
+export type Transport = "pg" | "in-process";
 export interface Interface {
+    readonly transport: Transport;
     readonly publish: (channel: string, payload: string) => Effect.Effect<void, SqlError>;
     readonly subscribe: (channel: string) => Stream.Stream<string, SqlError>;
 }

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

@@ -0,0 +1,13 @@
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+export type DbTimestamp = Date | string | number;
+export declare const Dialect: Schema.Literals<readonly ["pg", "mysql", "sqlite"]>;
+export type Dialect = typeof Dialect.Type;
+export declare const dialect: Effect.Effect<Dialect, never, SqlClient>;
+export declare const toDbDate: (timestamp: number) => Date;
+export declare const fromDbTimestamp: (timestamp: DbTimestamp) => number;
+export declare const fromNullableDbTimestamp: (timestamp: DbTimestamp | null | undefined) => number | undefined;
+export declare const timestampParam: (client: SqlClient, millis: number) => Date | number;
+export declare const encodeJson: (value: unknown) => string;
+export declare const decodeJson: (value: unknown) => unknown;
+export declare const decodeBool: (value: unknown) => boolean;

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

@@ -0,0 +1,36 @@
+import { Entity, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+declare const EntityRepositoryError_base: Schema.Class<EntityRepositoryError, Schema.TaggedStruct<"EntityRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class EntityRepositoryError extends EntityRepositoryError_base {
+}
+export interface CreateInstanceInput {
+    readonly kind: Ids.EntityKindName;
+    readonly key: Ids.EntityKey;
+    readonly addressId: Ids.AddressId;
+    readonly executionId: (generation: number) => Ids.ExecutionId;
+    readonly createdAt: number;
+}
+export interface Interface {
+    readonly putKind: (definition: Entity.KindDefinition) => Effect.Effect<Entity.KindDefinition, EntityRepositoryError>;
+    readonly getKind: (kind: Ids.EntityKindName) => Effect.Effect<Entity.KindDefinition | undefined, EntityRepositoryError>;
+    readonly listKinds: () => Effect.Effect<ReadonlyArray<Entity.KindDefinition>, EntityRepositoryError>;
+    readonly getOrCreate: (input: CreateInstanceInput) => Effect.Effect<Entity.Instance, EntityRepositoryError>;
+    readonly get: (kind: Ids.EntityKindName, key: Ids.EntityKey) => Effect.Effect<Entity.Instance | undefined, EntityRepositoryError>;
+    readonly destroy: (kind: Ids.EntityKindName, key: Ids.EntityKey, destroyedAt: number) => Effect.Effect<Entity.Instance | undefined, EntityRepositoryError>;
+    readonly list: (input: {
+        readonly kind?: Ids.EntityKindName;
+        readonly afterKind?: Ids.EntityKindName;
+        readonly afterKey?: string;
+        readonly limit?: number;
+    }) => Effect.Effect<ReadonlyArray<Entity.Instance>, EntityRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/EntityRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, SqlClient>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export {};

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

@@ -135,6 +135,7 @@ export interface Interface {
     readonly acceptEnvelope: (input: AcceptEnvelopeInput) => Effect.Effect<Envelope.EnvelopeAccepted, EnvelopeRepositoryError>;
     readonly getEnvelope: (id: Ids.EnvelopeId) => Effect.Effect<Envelope.Envelope | undefined, EnvelopeRepositoryError>;
     readonly getWait: (id: Ids.WaitId) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError>;
+    readonly findOpenByCorrelation?: (executionId: Ids.ExecutionId, correlationKey: string) => Effect.Effect<WaitRecord | undefined, EnvelopeRepositoryError>;
     readonly createWait: (input: CreateWaitInput) => Effect.Effect<WaitRecord, EnvelopeRepositoryError>;
     readonly listWaits: (input: ListWaitsInput) => Effect.Effect<ReadonlyArray<WaitRecord>, EnvelopeRepositoryError>;
     readonly listAllWaits: (input: ListAllWaitsInput) => Effect.Effect<ReadonlyArray<WaitRecord>, EnvelopeRepositoryError>;

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

@@ -1,7 +1,7 @@
 import { Execution, Ids } from "../../schema/index";
 import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
-import { Service as NotificationBusService } from "../database/notification-bus";
+import { Service as NotificationBusService, type Transport } from "../database/notification-bus";
 export declare const executionEventsChannel = "relay_execution_events";
 declare const DuplicateExecutionEvent_base: Schema.Class<DuplicateExecutionEvent, Schema.TaggedStruct<"DuplicateExecutionEvent", {
     readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
@@ -63,6 +63,7 @@ export interface ListAfterSequenceInput {
     readonly limit: number;
 }
 export interface Interface {
+    readonly signalTransport: Transport;
     readonly append: (input: Execution.ExecutionEvent) => Effect.Effect<Execution.ExecutionEvent, DuplicateExecutionEvent | ExecutionEventOrderViolation | ExecutionEventRepositoryError>;
     readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<Execution.ExecutionEvent>, ExecutionEventCursorNotFound | ExecutionEventRepositoryError>;
     readonly findBySequenceOrCursor: (input: FindBySequenceOrCursorInput) => Effect.Effect<Option.Option<Execution.ExecutionEvent>, ExecutionEventRepositoryError>;

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

@@ -1,6 +1,7 @@
 import { Agent, Execution, Ids, Shared } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { Service as NotificationBusService } from "../database/notification-bus";
 declare const ExecutionRepositoryError_base: Schema.Class<ExecutionRepositoryError, Schema.TaggedStruct<"ExecutionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -66,11 +67,19 @@ export interface ListExecutionsResult {
     readonly records: ReadonlyArray<ExecutionRecord>;
     readonly nextCursor?: ExecutionCursor;
 }
+export declare const executionsChangedChannel = "relay_executions_changed";
+export interface ListChangedSinceInput {
+    readonly updatedAtAfter: number;
+    readonly limit?: number;
+}
 export interface Interface {
     readonly create: (input: CreateExecutionInput) => Effect.Effect<ExecutionRecord, DuplicateExecution | ExecutionRepositoryError>;
     readonly get: (id: Ids.ExecutionId) => Effect.Effect<ExecutionRecord | undefined, ExecutionRepositoryError>;
     readonly list: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ExecutionRepositoryError>;
     readonly transition: (input: TransitionExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionNotFound | ExecutionRepositoryError>;
+    readonly notifyChanged: (record: ExecutionRecord) => Effect.Effect<void, ExecutionRepositoryError>;
+    readonly changedSignals: () => Stream.Stream<Ids.ExecutionId, ExecutionRepositoryError>;
+    readonly listChangedSince: (input: ListChangedSinceInput) => Effect.Effect<ReadonlyArray<ExecutionRecord>, ExecutionRepositoryError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionRepository", Interface>;
 export declare class Service extends Service_base {
@@ -88,9 +97,10 @@ export declare const ExecutionRow: Schema.Struct<{
     readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
     readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Number]>;
 }>;
+export declare const layerWithoutBus: Layer.Layer<Service, never, SqlClient | NotificationBusService>;
 export declare const layer: Layer.Layer<Service, never, SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Omit<Interface, "notifyChanged" | "changedSignals" | "listChangedSince"> & Partial<Pick<Interface, "notifyChanged" | "changedSignals" | "listChangedSince">>) => Layer.Layer<Service, never, never>;
 export declare const create: (input: CreateExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionRepositoryError | DuplicateExecution, Service>;
 export declare const get: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<ExecutionRecord | undefined, ExecutionRepositoryError, Service>;
 export declare const list: (input: ListExecutionsInput) => Effect.Effect<ListExecutionsResult, ExecutionRepositoryError, Service>;

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

@@ -0,0 +1,56 @@
+import { Ids, Inbox, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { AcceptEnvelopeInput } from "../envelope/envelope-repository";
+declare const InboxRepositoryError_base: Schema.Class<InboxRepositoryError, Schema.TaggedStruct<"InboxRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InboxRepositoryError extends InboxRepositoryError_base {
+}
+export interface DeliverInput {
+    readonly acceptance?: AcceptEnvelopeInput;
+    readonly executionId: Ids.ExecutionId;
+    readonly from: Ids.AddressId;
+    readonly envelopeId?: Ids.EnvelopeId;
+    readonly content: Inbox.Message["content"];
+    readonly replyWaitId?: Ids.WaitId;
+    readonly correlationKey?: string;
+    readonly idempotencyKey?: string;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface DeliverResult {
+    readonly message: Inbox.Message;
+    readonly deduplicated: boolean;
+    readonly eventSequence?: number;
+}
+export interface DrainInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly drainId: string;
+    readonly maxBatch?: number;
+    readonly consumedAt: number;
+    readonly createdAt: number;
+}
+export interface ListInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly includeConsumed?: boolean;
+    readonly afterSequence?: number;
+    readonly limit?: number;
+}
+export interface Interface {
+    readonly deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxRepositoryError>;
+    readonly drain: (input: DrainInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, InboxRepositoryError>;
+    readonly countUndrained: (executionId: Ids.ExecutionId) => Effect.Effect<number, InboxRepositoryError>;
+    readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<Inbox.Message>, InboxRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/InboxRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, SqlClient>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const deliver: (input: DeliverInput) => Effect.Effect<DeliverResult, InboxRepositoryError, Service>;
+export declare const drain: (input: DrainInput) => Effect.Effect<readonly Inbox.Message[], InboxRepositoryError, Service>;
+export declare const countUndrained: (id: Ids.ExecutionId) => Effect.Effect<number, InboxRepositoryError, Service>;
+export declare const list: (input: ListInput) => Effect.Effect<readonly Inbox.Message[], InboxRepositoryError, Service>;
+export {};

package/dist/types/store-sql/index.d.ts

@@ -5,13 +5,19 @@ export * as ChildExecutionRepository from "./child/child-execution-repository";
 export * as ClusterRegistryRepository from "./cluster/cluster-registry-repository";
 export * as CompactionRepository from "./compaction/compaction-repository";
 export * as Database from "./database/database-service";
+export * as SqlDialect from "./database/sql-dialect";
 export * as EnvelopeRepository from "./envelope/envelope-repository";
+export * as EntityRepository from "./entity/entity-repository";
 export * as ExecutionEventRepository from "./execution/execution-event-repository";
 export * as ExecutionRepository from "./execution/execution-repository";
+export * as ExecutionStateRepository from "./state/execution-state-repository";
 export * as IdempotencyRepository from "./idempotency/idempotency-repository";
+export * as InboxRepository from "./inbox/inbox-repository";
+export * as TopicRepository from "./topic/topic-repository";
 export * as MemoryRepository from "./memory/memory-repository";
 export * as NotificationBus from "./database/notification-bus";
 export * as PermissionRuleRepository from "./permission/permission-rule-repository";
+export * as PresenceRepository from "./presence/presence-repository";
 export * as ContextEpochRepository from "./session/context-epoch-repository";
 export * as RelaySchema from "./schema/relay-schema";
 export * as ScheduleRepository from "./schedule/schedule-repository";

package/dist/types/store-sql/portable.d.ts

@@ -0,0 +1,27 @@
+export * as AddressBookRepository from "./address/address-book-repository";
+export * as AgentChatRepository from "./chat/agent-chat-repository";
+export * as AgentDefinitionRepository from "./agent/agent-definition-repository";
+export * as ChildExecutionRepository from "./child/child-execution-repository";
+export * as ClusterRegistryRepository from "./cluster/cluster-registry-repository";
+export * as CompactionRepository from "./compaction/compaction-repository";
+export * as ContextEpochRepository from "./session/context-epoch-repository";
+export * as EnvelopeRepository from "./envelope/envelope-repository";
+export * as EntityRepository from "./entity/entity-repository";
+export * as ExecutionEventRepository from "./execution/execution-event-repository";
+export * as ExecutionRepository from "./execution/execution-repository";
+export * as ExecutionStateRepository from "./state/execution-state-repository";
+export * as IdempotencyRepository from "./idempotency/idempotency-repository";
+export * as InboxRepository from "./inbox/inbox-repository";
+export * as TopicRepository from "./topic/topic-repository";
+export * as MemoryRepository from "./memory/memory-repository";
+export * as NotificationBus from "./database/notification-bus";
+export * as PermissionRuleRepository from "./permission/permission-rule-repository";
+export * as PresenceRepository from "./presence/presence-repository";
+export * as ScheduleRepository from "./schedule/schedule-repository";
+export * as SessionRepository from "./session/session-repository";
+export * as SkillDefinitionRepository from "./skill/skill-definition-repository";
+export * as SqlDialect from "./database/sql-dialect";
+export * as SteeringRepository from "./steering/steering-repository";
+export * as TenantId from "./tenant/tenant-id";
+export * as ToolCallRepository from "./tool/tool-call-repository";
+export * as WorkspaceLeaseRepository from "./workspace/workspace-lease-repository";