@relayfx/sdk 0.3.6 → 0.4.0

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

@@ -0,0 +1,338 @@
+import { type Workspace } from "../../schema/index";
+export declare const relayWorkspaceLeases: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "relay_workspace_leases";
+    schema: undefined;
+    columns: {
+        tenantId: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.TenantId">>>>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.TenantId">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        id: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">>>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        executionId: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetNotNull<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_workspace_leases";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        providerKey: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string>>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        sandboxRef: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.WorkspaceRef">>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.WorkspaceRef">;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        latestSnapshotRef: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.SnapshotRef">>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        status: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, "archived" | "failed" | "planned" | "released" | "running" | "snapshotted" | "suspended">>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: "archived" | "failed" | "planned" | "released" | "running" | "snapshotted" | "suspended";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        resumeStrategy: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, "reattach" | "restore_snapshot">>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: "reattach" | "restore_snapshot";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        region: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        requestJson: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgJsonbBuilder, Workspace.WorkspaceRequest | null>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "object json";
+            data: Workspace.WorkspaceRequest | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        metadataJson: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", 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;
+        }>>>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "object json";
+            data: {
+                readonly [x: string]: import("effect/Schema").Json;
+            };
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        updatedAt: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_leases", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>, {
+            name: string;
+            tableName: "relay_workspace_leases";
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: 'pg';
+}>;
+export declare const relayWorkspaceSnapshots: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "relay_workspace_snapshots";
+    schema: undefined;
+    columns: {
+        tenantId: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.TenantId">>>>, {
+            name: string;
+            tableName: "relay_workspace_snapshots";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.TenantId">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        id: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.WorkspaceSnapshotId">>>, {
+            name: string;
+            tableName: "relay_workspace_snapshots";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.WorkspaceSnapshotId">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        leaseId: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">>>, {
+            name: string;
+            tableName: "relay_workspace_snapshots";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.WorkspaceLeaseId">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        executionId: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", import("drizzle-orm/pg-core").SetNotNull<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_workspace_snapshots";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        reason: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, "before_child_fork" | "before_wait" | "manual" | "on_complete" | "on_failure">>, {
+            name: string;
+            tableName: "relay_workspace_snapshots";
+            dataType: "string";
+            data: "before_child_fork" | "before_wait" | "manual" | "on_complete" | "on_failure";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        snapshotRef: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, string & import("effect/Brand").Brand<"Relay.SnapshotRef">>>, {
+            name: string;
+            tableName: "relay_workspace_snapshots";
+            dataType: "string";
+            data: string & import("effect/Brand").Brand<"Relay.SnapshotRef">;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        metadataJson: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", 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;
+        }>>>, {
+            name: string;
+            tableName: "relay_workspace_snapshots";
+            dataType: "object json";
+            data: {
+                readonly [x: string]: import("effect/Schema").Json;
+            };
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgBuildColumn<"relay_workspace_snapshots", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>, {
+            name: string;
+            tableName: "relay_workspace_snapshots";
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: 'pg';
+}>;

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

@@ -0,0 +1,52 @@
+import { Ids, Shared } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import { Prompt } from "effect/unstable/ai";
+import type { AppendEntryInput, AppendSessionEntryInput, SessionConflict, SessionEntryRecord, SessionRepositoryError } from "./session-repository";
+export declare const sessionEntryRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly session_id: Schema.String;
+    readonly parent_id: Schema.Union<readonly [Schema.String, Schema.Null, Schema.Undefined]>;
+    readonly tag: Schema.String;
+    readonly payload_json: Schema.Unknown;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+}>;
+declare const appendToRecord: (input: AppendEntryInput) => SessionEntryRecord;
+interface SessionEntryRecordErrors {
+    readonly SessionRepositoryError: Schema.Schema<SessionRepositoryError> & {
+        readonly make: (input: {
+            readonly message: string;
+        }) => SessionRepositoryError;
+    };
+    readonly SessionConflict: {
+        readonly make: (input: {
+            readonly reason: SessionConflict["reason"];
+            readonly message: string;
+        }) => SessionConflict;
+    };
+}
+export declare const makeSessionEntryRecords: (errors: SessionEntryRecordErrors) => {
+    payloadFromInput: (input: AppendSessionEntryInput) => unknown;
+    toEntryRecord: (row: typeof sessionEntryRow.Type) => Effect.Effect<SessionEntryRecord, SessionRepositoryError>;
+    sameEntry: (left: SessionEntryRecord, right: SessionEntryRecord) => boolean;
+    appendToRecord: typeof appendToRecord;
+    missingEntry: (id: Ids.SessionEntryId) => SessionRepositoryError;
+    conflictingEntry: (id: Ids.SessionEntryId) => SessionRepositoryError;
+    conflict: (reason: SessionConflict["reason"], message: string) => SessionConflict;
+    cloneEntry: (record: SessionEntryRecord) => SessionEntryRecord;
+    cloneCheckpoint: (record: Extract<SessionEntryRecord, {
+        readonly _tag: "Compaction";
+        readonly version: 2;
+    }>) => {
+        projectedHistory: Prompt.Prompt;
+        id: Ids.SessionEntryId;
+        sessionId: Ids.SessionId;
+        parentId: Ids.SessionEntryId | null;
+        _tag: "Compaction";
+        version: 2;
+        summary?: string;
+        metadata?: Shared.Metadata;
+        createdAt: number;
+    };
+    validateCompaction: (currentPath: ReadonlyArray<SessionEntryRecord>, input: AppendEntryInput) => Effect.Effect<void, SessionRepositoryError>;
+};
+export {};

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

@@ -0,0 +1,51 @@
+import { Ids, Shared } from "../../schema/index";
+import { Effect, Schema } 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;
+};
+export declare const makeSessionRepository: (errors: SessionRecordErrors) => Effect.Effect<Interface, never, SqlClient>;
+export { sessionEntryRow };

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

@@ -1,7 +1,6 @@
 import { Ids, Shared } from "../../schema/index";
 import { Context, Effect, Layer, Schema } from "effect";
 import { Prompt } from "effect/unstable/ai";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
 declare const SessionRepositoryError_base: Schema.Class<SessionRepositoryError, Schema.TaggedStruct<"SessionRepositoryError", {
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -256,8 +255,8 @@ export declare const SessionEntryRow: Schema.Struct<{
     readonly payload_json: Schema.Unknown;
     readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
 }>;
-export declare const layer: Layer.Layer<Service, never, SqlClient>;
-export declare const layerFromTenant: Layer.Layer<Service, never, SqlClient>;
+export declare const layer: Layer.Layer<Service, never, import("effect/unstable/sql/SqlClient").SqlClient>;
+export declare const layerFromTenant: Layer.Layer<Service, never, import("effect/unstable/sql/SqlClient").SqlClient>;
 export declare const memoryLayer: Layer.Layer<Service, never, never>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const create: (input: CreateSessionInput) => Effect.Effect<SessionRecord, DuplicateSession | SessionRepositoryError, Service>;

package/dist/types/store-sql/tool/tool-attempt-records.d.ts

@@ -0,0 +1,52 @@
+import { Effect, Schema } from "effect";
+import type { SqlClient } from "effect/unstable/sql/SqlClient";
+import type { ToolAttemptRecord, ToolCallRepositoryError } from "./tool-call-repository";
+export declare const toolAttemptRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly tool_call_id: Schema.String;
+    readonly attempt_number: Schema.Union<readonly [Schema.Finite, Schema.String, Schema.BigInt]>;
+    readonly state: Schema.String;
+    readonly worker_id: Schema.NullishOr<Schema.String>;
+    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
+    readonly error: Schema.NullishOr<Schema.String>;
+    readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly completed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
+}>;
+export declare const toolAttemptId: (attemptNumber: number) => string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+interface MakeToolAttemptRecordOperationsInput {
+    readonly sql: SqlClient;
+    readonly ts: (millis: number) => Date | number;
+    readonly toRepositoryError: (error: unknown) => ToolCallRepositoryError;
+    readonly ToolCallRepositoryError: {
+        readonly make: (input: {
+            readonly message: string;
+        }) => ToolCallRepositoryError;
+    };
+}
+export declare const makeToolAttemptRecordOperations: ({ sql, ts, toRepositoryError, ToolCallRepositoryError, }: MakeToolAttemptRecordOperationsInput) => {
+    attemptColumns: import("effect/unstable/sql/Statement").Fragment;
+    readAttempts: (tenantId: string & import("effect/Brand").Brand<"Relay.TenantId">, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<ToolAttemptRecord[], ToolCallRepositoryError, never>;
+    nextAttemptNumber: (tenantId: string & import("effect/Brand").Brand<"Relay.TenantId">, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<number, ToolCallRepositoryError, never>;
+    insertAttemptNumber: (tenantId: string & import("effect/Brand").Brand<"Relay.TenantId">, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">, attemptNumber: number, createdAt: number, workerId?: string | undefined, claimExpiresAt?: number | undefined) => Effect.Effect<{
+        id: string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+        callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+        attemptNumber: number;
+        state: "running";
+        workerId?: string;
+        claimExpiresAt?: number;
+        createdAt: number;
+    }, ToolCallRepositoryError, never>;
+    insertAttempt: (tenantId: string & import("effect/Brand").Brand<"Relay.TenantId">, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">, createdAt: number, workerId?: string | undefined, claimExpiresAt?: number | undefined) => Effect.Effect<{
+        id: string & import("effect/Brand").Brand<"Relay.ToolAttemptId">;
+        callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+        attemptNumber: number;
+        state: "running";
+        workerId?: string;
+        claimExpiresAt?: number;
+        createdAt: number;
+    }, ToolCallRepositoryError, never>;
+    loadAttempt: (tenantId: string & import("effect/Brand").Brand<"Relay.TenantId">, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">, attemptId: string & import("effect/Brand").Brand<"Relay.ToolAttemptId">) => Effect.Effect<ToolAttemptRecord | undefined, ToolCallRepositoryError, never>;
+    completeAttempt: (tenantId: string & import("effect/Brand").Brand<"Relay.TenantId">, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">, attemptId: string & import("effect/Brand").Brand<"Relay.ToolAttemptId">, state: "abandoned" | "completed" | "expired" | "failed" | "released", completedAt: number, error?: string | undefined) => Effect.Effect<ToolAttemptRecord, ToolCallRepositoryError, never>;
+};
+export type ToolAttemptRecordOperations = ReturnType<typeof makeToolAttemptRecordOperations>;
+export {};

package/dist/types/store-sql/tool/tool-call-records.d.ts

@@ -0,0 +1,121 @@
+import { Ids, Shared, Tool } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql/SqlClient";
+import { toolAttemptRow } from "./tool-attempt-records";
+import type { DuplicateToolCall, DuplicateToolResult, Interface, RecordCallInput, RecordResultInput, ToolCallConflict, ToolCallNotFound, ToolCallRecord, ToolCallRepositoryError, ToolCallTransitionRejected, ToolClaimRejected, ToolOutcomeConflict } from "./tool-call-repository";
+export declare const toolCallRow: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly execution_id: Schema.String;
+    readonly name: Schema.String;
+    readonly input_json: Schema.Unknown;
+    readonly definition_json: Schema.NullishOr<Schema.Unknown>;
+    readonly placement_kind: Schema.String;
+    readonly placement_key: Schema.NullishOr<Schema.String>;
+    readonly state: Schema.String;
+    readonly wait_id: Schema.NullishOr<Schema.String>;
+    readonly idempotency_key: Schema.String;
+    readonly available_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    readonly active_attempt_id: Schema.NullishOr<Schema.String>;
+    readonly claim_owner: Schema.NullishOr<Schema.String>;
+    readonly claimed_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
+    readonly claim_expires_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
+    readonly external_outcome_json: Schema.NullishOr<Schema.Unknown>;
+    readonly external_outcome_at: Schema.NullishOr<Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>>;
+    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 toolResultRow: Schema.Struct<{
+    readonly tool_call_id: Schema.String;
+    readonly output_json: Schema.Unknown;
+    readonly error: Schema.NullishOr<Schema.String>;
+    readonly metadata_json: Schema.Unknown;
+    readonly created_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 normalizeCall: (call: Tool.Call) => Tool.Call;
+declare const sameCallIdentity: (left: Tool.Call, right: Tool.Call) => boolean;
+export declare const toolCallRecordIdentity: {
+    sameCallIdentity: typeof sameCallIdentity;
+};
+export interface ToolRecordErrors {
+    readonly ToolCallRepositoryError: {
+        readonly make: (input: {
+            readonly message: string;
+        }) => ToolCallRepositoryError;
+    };
+    readonly ToolCallNotFound: {
+        readonly make: (input: {
+            readonly id: Ids.ToolCallId;
+        }) => ToolCallNotFound;
+    };
+    readonly DuplicateToolCall: {
+        readonly make: (input: {
+            readonly id: Ids.ToolCallId;
+        }) => DuplicateToolCall;
+    };
+    readonly DuplicateToolResult: {
+        readonly make: (input: {
+            readonly call_id: Ids.ToolCallId;
+        }) => DuplicateToolResult;
+    };
+    readonly ToolCallConflict: {
+        readonly make: (input: {
+            readonly id: Ids.ToolCallId;
+        }) => ToolCallConflict;
+    };
+    readonly ToolCallTransitionRejected: {
+        readonly make: (input: {
+            readonly id: Ids.ToolCallId;
+            readonly message: string;
+        }) => ToolCallTransitionRejected;
+    };
+    readonly ToolOutcomeConflict: {
+        readonly make: (input: {
+            readonly id: Ids.ToolCallId;
+        }) => ToolOutcomeConflict;
+    };
+    readonly ToolClaimRejected: {
+        readonly make: (input: {
+            readonly message: string;
+        }) => ToolClaimRejected;
+    };
+}
+interface MakeToolCallRecordSupportInput {
+    readonly sql: SqlClient;
+    readonly errors: ToolRecordErrors;
+    readonly toolCallIdempotencyKey: (tenantId: Ids.TenantId, executionId: Ids.ExecutionId, callId: Ids.ToolCallId) => string;
+}
+export declare const makeToolCallRecordSupport: ({ sql, errors, toolCallIdempotencyKey }: MakeToolCallRecordSupportInput) => {
+    sql: SqlClient;
+    ts: (millis: number) => number | Date;
+    repositoryTransaction: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, ToolCallRepositoryError | Exclude<E, {
+        readonly _tag: "SqlError";
+    }>, R>;
+    callColumns: import("effect/unstable/sql/Statement").Fragment;
+    selectCallByKey: (tenantId: Ids.TenantId, executionId: Ids.ExecutionId, id: Ids.ToolCallId) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>;
+    selectResultByKey: (tenantId: Ids.TenantId, executionId: Ids.ExecutionId, callId: Ids.ToolCallId) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>;
+    insertCallIgnore: ((tenantId: Ids.TenantId, input: RecordCallInput, definition?: Tool.Definition, placement?: Tool.Placement) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>) | ((tenantId: Ids.TenantId, input: RecordCallInput, definition?: Tool.Definition, placement?: Tool.Placement) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>);
+    insertCall: ((tenantId: Ids.TenantId, input: RecordCallInput, definition?: Tool.Definition, placement?: Tool.Placement) => Effect.Effect<readonly import("effect/unstable/sql/SqlConnection").Row[], import("effect/unstable/sql/SqlError").SqlError, never>) | ((tenantId: Ids.TenantId, input: RecordCallInput, definition?: Tool.Definition, placement?: Tool.Placement) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>);
+    insertResultStatement: (tenantId: Ids.TenantId, input: RecordResultInput) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>;
+    lockedCallRows: ((tenantId: Ids.TenantId, executionId: Ids.ExecutionId, id: Ids.ToolCallId) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>) | ((tenantId: Ids.TenantId, executionId: Ids.ExecutionId, callId: Ids.ToolCallId) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>) | ((tenantId: Ids.TenantId, executionId: Ids.ExecutionId, callId: Ids.ToolCallId) => import("effect/unstable/sql/Statement").Statement<import("effect/unstable/sql/SqlConnection").Row>);
+    decodeResultRow: (row: unknown) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly tool_call_id: Schema.String;
+        readonly output_json: Schema.Unknown;
+        readonly error: Schema.NullishOr<Schema.String>;
+        readonly metadata_json: Schema.Unknown;
+        readonly created_at: Schema.Union<readonly [Schema.Date, Schema.String, Schema.Finite]>;
+    }, "Type">, ToolCallRepositoryError, never>;
+    decodeCall: (row: unknown) => Effect.Effect<ToolCallRecord, ToolCallRepositoryError, never>;
+    readLockedCall: (tenantId: string & import("effect/Brand").Brand<"Relay.TenantId">, executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">, callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<ToolCallRecord, ToolCallNotFound | ToolCallRepositoryError, never>;
+    toRepositoryError: (error: unknown) => ToolCallRepositoryError;
+};
+export type ToolCallRecordSupport = ReturnType<typeof makeToolCallRecordSupport>;
+interface MakeToolCallRepositoryInput {
+    readonly errors: ToolRecordErrors;
+    readonly toolCallIdempotencyKey: (tenantId: Ids.TenantId, executionId: Ids.ExecutionId, callId: Ids.ToolCallId) => string;
+}
+export declare const makeToolCallRepository: ({ errors, toolCallIdempotencyKey, }: MakeToolCallRepositoryInput) => Effect.Effect<Interface, never, SqlClient>;
+export { toolAttemptRow };