@relayfx/sdk 0.4.2 → 0.6.0

package/dist/types/store-sql/schema/session-schema.d.ts

@@ -62,6 +62,51 @@ export declare const relaySessions: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }>;
+        ownerExecutionId: import("drizzle-orm/pg-core").PgBuildColumn<"relay_sessions", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.ExecutionId">>, {
+            name: string;
+            tableName: "relay_sessions";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        ownerEpoch: import("drizzle-orm/pg-core").PgBuildColumn<"relay_sessions", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBigInt53Builder>>, {
+            name: string;
+            tableName: "relay_sessions";
+            dataType: "number int53";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        ownerReleased: import("drizzle-orm/pg-core").PgBuildColumn<"relay_sessions", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBooleanBuilder>>, {
+            name: string;
+            tableName: "relay_sessions";
+            dataType: "boolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
         metadataJson: import("drizzle-orm/pg-core").PgBuildColumn<"relay_sessions", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgJsonbBuilder, {
             readonly [x: string]: import("effect/Schema").Json;
         }>>>, {

package/dist/types/store-sql/session/session-records.d.ts

@@ -1,51 +1,9 @@
-import { Ids, Shared } from "../../schema/index";
-import { Effect, Schema } from "effect";
+import { Effect } from "effect";
 import { SqlClient } from "effect/unstable/sql/SqlClient";
 import { sessionEntryRow } from "./session-entry-records";
-import type { DuplicateSession, Interface, ListSessionsInput, SessionConflict, SessionCursor, SessionRecord, SessionRepositoryError } from "./session-repository";
-export declare const sessionRow: Schema.Struct<{
-    readonly id: Schema.String;
-    readonly root_address_id: Schema.String;
-    readonly leaf_entry_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
-    readonly metadata_json: Schema.Unknown;
-    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
-    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
-}>;
-export declare const metadata: (input: Shared.Metadata | undefined) => {
-    readonly [x: string]: Schema.Json;
-};
-export declare const listLimit: (input: ListSessionsInput) => number;
-declare const nextCursorOf: (records: ReadonlyArray<SessionRecord>, fetched: number, limit: number) => SessionCursor | undefined;
-declare const compareDesc: (left: SessionRecord, right: SessionRecord) => number;
-declare const afterCursor: (record: SessionRecord, cursor: SessionCursor | undefined) => boolean;
-export declare const sessionRecordPaging: {
-    nextCursorOf: typeof nextCursorOf;
-    compareDesc: typeof compareDesc;
-    afterCursor: typeof afterCursor;
-};
-interface SessionRecordErrors {
-    readonly SessionRepositoryError: Schema.Schema<SessionRepositoryError> & {
-        readonly make: (input: {
-            readonly message: string;
-        }) => SessionRepositoryError;
-    };
-    readonly DuplicateSession: {
-        readonly make: (input: {
-            readonly id: Ids.SessionId;
-        }) => DuplicateSession;
-    };
-    readonly SessionConflict: {
-        readonly make: (input: {
-            readonly reason: SessionConflict["reason"];
-            readonly message: string;
-        }) => SessionConflict;
-    };
-}
-export declare const makeSessionRecordSupport: (errors: SessionRecordErrors) => {
-    missingSession: (id: Ids.SessionId) => SessionRepositoryError;
-    rootMismatch: (id: Ids.SessionId) => SessionRepositoryError;
-    cloneSession: (record: SessionRecord) => SessionRecord;
-    currentLeaf: (session: SessionRecord) => Ids.SessionEntryId | null;
-};
+import type { Interface } from "./session-repository";
+export { listLimit, metadata, sessionRow, sessionRecordPaging, toSessionRecord } from "./session-row";
+import { type SessionRecordErrors } from "./session-row";
+export { makeSessionRecordSupport, type SessionRecordErrors } from "./session-row";
 export declare const makeSessionRepository: (errors: SessionRecordErrors) => Effect.Effect<Interface, never, SqlClient>;
 export { sessionEntryRow };

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

@@ -14,15 +14,42 @@ declare const DuplicateSession_base: Schema.Class<DuplicateSession, Schema.Tagge
 export declare class DuplicateSession extends DuplicateSession_base {
 }
 declare const SessionConflict_base: Schema.Class<SessionConflict, Schema.TaggedStruct<"SessionConflict", {
-    readonly reason: Schema.Literals<readonly ["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path"]>;
+    readonly reason: Schema.Literals<readonly ["stale-leaf", "checkpoint-id-reused", "checkpoint-not-on-active-path", "fenced"]>;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SessionConflict extends SessionConflict_base {
 }
+export interface SessionWriter {
+    readonly executionId: Ids.ExecutionId;
+    readonly epoch: number;
+    readonly released: boolean;
+}
+export interface ExpectedSessionWriter {
+    readonly executionId: Ids.ExecutionId;
+    readonly epoch: number;
+}
+export interface ClaimSessionWriterInput {
+    readonly sessionId: Ids.SessionId;
+    readonly executionId: Ids.ExecutionId;
+    readonly now: number;
+}
+export interface ReleaseSessionWriterInput {
+    readonly sessionId: Ids.SessionId;
+    readonly executionId: Ids.ExecutionId;
+    readonly now: number;
+}
+export type ClaimSessionWriterResult = {
+    readonly _tag: "Claimed";
+    readonly writer: SessionWriter;
+} | {
+    readonly _tag: "Busy";
+    readonly writer: SessionWriter;
+};
 export interface SessionRecord {
     readonly id: Ids.SessionId;
     readonly rootAddressId: Ids.AddressId;
     readonly leafEntryId?: Ids.SessionEntryId;
+    readonly writer?: SessionWriter;
     readonly metadata: Shared.Metadata;
     readonly createdAt: number;
     readonly updatedAt: number;
@@ -197,6 +224,7 @@ export interface AppendEntryInput {
     readonly input: AppendSessionEntryInput;
     readonly createdAt: number;
     readonly expectedLeafId?: Ids.SessionEntryId | null;
+    readonly expectedWriter?: ExpectedSessionWriter;
 }
 export interface AppendCheckpointInput {
     readonly id: Ids.SessionEntryId;
@@ -205,6 +233,7 @@ export interface AppendCheckpointInput {
     readonly projectedHistory: Prompt.Prompt;
     readonly summary?: string;
     readonly createdAt: number;
+    readonly expectedWriter?: ExpectedSessionWriter;
 }
 export interface AppendCheckpointResult {
     readonly _tag: "Appended" | "AlreadyPresent";
@@ -226,6 +255,8 @@ export interface SetLeafInput {
 export interface Interface {
     readonly create: (input: CreateSessionInput) => Effect.Effect<SessionRecord, DuplicateSession | SessionRepositoryError>;
     readonly ensure: (input: EnsureSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError>;
+    readonly claimWriter: (input: ClaimSessionWriterInput) => Effect.Effect<ClaimSessionWriterResult, SessionRepositoryError>;
+    readonly releaseWriter: (input: ReleaseSessionWriterInput) => Effect.Effect<void, SessionRepositoryError>;
     readonly get: (id: Ids.SessionId) => Effect.Effect<SessionRecord | undefined, SessionRepositoryError>;
     readonly list: (input: ListSessionsInput) => Effect.Effect<ListSessionsResult, SessionRepositoryError>;
     readonly touch: (input: TouchSessionInput) => Effect.Effect<SessionRecord, SessionRepositoryError>;
@@ -243,6 +274,9 @@ export declare const SessionRow: Schema.Struct<{
     readonly id: Schema.String;
     readonly root_address_id: Schema.String;
     readonly leaf_entry_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
+    readonly owner_execution_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
+    readonly owner_epoch: Schema.Union<readonly [Schema.Finite, Schema.String, Schema.BigInt]>;
+    readonly owner_released: Schema.Union<readonly [Schema.Boolean, Schema.Finite, Schema.String, Schema.BigInt]>;
     readonly metadata_json: Schema.Unknown;
     readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
     readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;

package/dist/types/store-sql/session/session-row.d.ts

@@ -0,0 +1,60 @@
+import { Ids, Shared } from "../../schema/index";
+import { Schema } from "effect";
+import type { DuplicateSession, ExpectedSessionWriter, ListSessionsInput, SessionConflict, SessionCursor, SessionRecord, SessionRepositoryError, SessionWriter } from "./session-repository";
+export declare const sessionRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly root_address_id: Schema.String;
+    readonly leaf_entry_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
+    readonly owner_execution_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
+    readonly owner_epoch: Schema.Union<readonly [Schema.Finite, Schema.String, Schema.BigInt]>;
+    readonly owner_released: Schema.Union<readonly [Schema.Boolean, Schema.Finite, Schema.String, Schema.BigInt]>;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly updated_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+}>;
+export declare const CountRow: Schema.Struct<{
+    readonly value: Schema.Union<readonly [Schema.Finite, Schema.String, Schema.BigInt]>;
+}>;
+export declare const metadata: (input: Shared.Metadata | undefined) => {
+    readonly [x: string]: Schema.Json;
+};
+export declare const toSessionRecord: (row: typeof sessionRow.Type) => SessionRecord;
+export declare const listLimit: (input: ListSessionsInput) => number;
+declare const nextCursorOf: (records: ReadonlyArray<SessionRecord>, fetched: number, limit: number) => SessionCursor | undefined;
+declare const compareDesc: (left: SessionRecord, right: SessionRecord) => number;
+declare const afterCursor: (record: SessionRecord, cursor: SessionCursor | undefined) => boolean;
+export declare const sessionRecordPaging: {
+    nextCursorOf: typeof nextCursorOf;
+    compareDesc: typeof compareDesc;
+    afterCursor: typeof afterCursor;
+};
+export interface SessionRecordErrors {
+    readonly SessionRepositoryError: Schema.Schema<SessionRepositoryError> & {
+        readonly make: (input: {
+            readonly message: string;
+        }) => SessionRepositoryError;
+    };
+    readonly DuplicateSession: {
+        readonly make: (input: {
+            readonly id: Ids.SessionId;
+        }) => DuplicateSession;
+    };
+    readonly SessionConflict: {
+        readonly make: (input: {
+            readonly reason: SessionConflict["reason"];
+            readonly message: string;
+        }) => SessionConflict;
+    };
+}
+export declare const makeSessionRecordSupport: (errors: SessionRecordErrors) => {
+    missingSession: (id: Ids.SessionId) => SessionRepositoryError;
+    rootMismatch: (id: Ids.SessionId) => SessionRepositoryError;
+    cloneSession: (record: SessionRecord) => SessionRecord;
+    currentLeaf: (session: SessionRecord) => Ids.SessionEntryId | null;
+    writerFenceViolation: (session: SessionRecord, expected: ExpectedSessionWriter | undefined) => string | undefined;
+    nextWriterClaim: (current: SessionWriter | undefined, executionId: Ids.ExecutionId) => {
+        readonly _tag: "Claimed" | "Busy";
+        readonly writer: SessionWriter;
+    };
+};
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@relayfx/sdk",
-  "version": "0.4.2",
+  "version": "0.6.0",
   "description": "Effect-native durable execution SDK for addressable agents and tools",
   "type": "module",
   "exports": {
@@ -57,8 +57,8 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.7.0",
-    "@batonfx/providers": "0.7.0",
+    "@batonfx/core": "0.9.0",
+    "@batonfx/providers": "0.9.0",
     "@effect/ai-anthropic": "4.0.0-beta.98",
     "@effect/ai-openai": "4.0.0-beta.98",
     "@effect/ai-openai-compat": "4.0.0-beta.98",