@relayfx/sdk 0.0.1

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

@@ -0,0 +1,80 @@
+import { Agent, Execution, Ids, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const ExecutionRepositoryError_base: Schema.Class<ExecutionRepositoryError, Schema.TaggedStruct<"ExecutionRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionRepositoryError extends ExecutionRepositoryError_base {
+}
+declare const DuplicateExecution_base: Schema.Class<DuplicateExecution, Schema.TaggedStruct<"DuplicateExecution", {
+    readonly id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateExecution extends DuplicateExecution_base {
+}
+declare const ExecutionNotFound_base: Schema.Class<ExecutionNotFound, Schema.TaggedStruct<"ExecutionNotFound", {
+    readonly id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ExecutionNotFound extends ExecutionNotFound_base {
+}
+export interface ExecutionRecord {
+    readonly id: Ids.ExecutionId;
+    readonly rootAddressId: Ids.AddressId;
+    readonly status: Execution.ExecutionStatus;
+    readonly agentDefinitionId?: Ids.AgentDefinitionId;
+    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
+    readonly agentDefinitionSnapshot?: Agent.Definition;
+    readonly metadata: Shared.Metadata;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface CreateExecutionInput {
+    readonly id: Ids.ExecutionId;
+    readonly rootAddressId: Ids.AddressId;
+    readonly status: Execution.ExecutionStatus;
+    readonly agentDefinitionId?: Ids.AgentDefinitionId;
+    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
+    readonly agentDefinitionSnapshot?: Agent.Definition;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface TransitionExecutionInput {
+    readonly id: Ids.ExecutionId;
+    readonly status: Execution.ExecutionStatus;
+    readonly metadata?: Shared.Metadata;
+    readonly updatedAt: number;
+}
+export interface ExecutionCursor {
+    readonly updatedAt: number;
+    readonly id: Ids.ExecutionId;
+}
+export interface ListExecutionsInput {
+    readonly rootAddressId?: Ids.AddressId;
+    readonly status?: Execution.ExecutionStatus;
+    readonly limit?: number;
+    readonly cursor?: ExecutionCursor;
+}
+export interface ListExecutionsResult {
+    readonly records: ReadonlyArray<ExecutionRecord>;
+    readonly nextCursor?: ExecutionCursor;
+}
+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>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ExecutionRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+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: 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>;
+export declare const transition: (input: TransitionExecutionInput) => Effect.Effect<ExecutionRecord, ExecutionRepositoryError | ExecutionNotFound, Service>;
+export {};

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

@@ -0,0 +1,42 @@
+import { Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const IdempotencyRepositoryError_base: Schema.Class<IdempotencyRepositoryError, Schema.TaggedStruct<"IdempotencyRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class IdempotencyRepositoryError extends IdempotencyRepositoryError_base {
+}
+export interface OperationInput {
+    readonly scope: string;
+    readonly operation: string;
+    readonly key: string;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+    readonly expiresAt?: number;
+}
+export interface IdempotencyRecord {
+    readonly scope: string;
+    readonly operation: string;
+    readonly key: string;
+    readonly result: Shared.JsonValue;
+    readonly metadata: Shared.Metadata;
+    readonly createdAt: number;
+    readonly expiresAt?: number;
+}
+export interface IdempotencyOutcome {
+    readonly replayed: boolean;
+    readonly record: IdempotencyRecord;
+}
+export interface Interface {
+    readonly runOnce: <R>(input: OperationInput, create: Effect.Effect<Shared.JsonValue, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, R>;
+    readonly transaction: <A, R>(effect: Effect.Effect<A, IdempotencyRepositoryError, R>) => Effect.Effect<A, IdempotencyRepositoryError, R>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/IdempotencyRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+export declare const memoryLayer: Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const runOnce: <R>(input: OperationInput, create: Effect.Effect<Shared.JsonValue, IdempotencyRepositoryError, R>) => Effect.Effect<IdempotencyOutcome, IdempotencyRepositoryError, Service | R>;
+export declare const transaction: <A, R>(effect: Effect.Effect<A, IdempotencyRepositoryError, R>) => Effect.Effect<A, IdempotencyRepositoryError, Service | R>;
+export {};

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

@@ -0,0 +1,15 @@
+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 Database from "./database/database-service";
+export * as EnvelopeRepository from "./envelope/envelope-repository";
+export * as ExecutionEventRepository from "./execution/execution-event-repository";
+export * as ExecutionRepository from "./execution/execution-repository";
+export * as IdempotencyRepository from "./idempotency/idempotency-repository";
+export * as RelaySchema from "./schema/relay-schema";
+export * as ScheduleRepository from "./schedule/schedule-repository";
+export * as ToolCallRepository from "./tool/tool-call-repository";
+export * as WorkspaceLeaseRepository from "./workspace/workspace-lease-repository";
+export declare const storeSqlPackage = "./index";

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

@@ -0,0 +1,83 @@
+import { Content, Ids, Schedule, Shared } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const ScheduleRepositoryError_base: Schema.Class<ScheduleRepositoryError, Schema.TaggedStruct<"ScheduleRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ScheduleRepositoryError extends ScheduleRepositoryError_base {
+}
+declare const ScheduleNotFound_base: Schema.Class<ScheduleNotFound, Schema.TaggedStruct<"ScheduleNotFound", {
+    readonly id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ScheduleNotFound extends ScheduleNotFound_base {
+}
+declare const ScheduleClaimMismatch_base: Schema.Class<ScheduleClaimMismatch, Schema.TaggedStruct<"ScheduleClaimMismatch", {
+    readonly id: Schema.brand<Schema.String, "Relay.ScheduleId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ScheduleId">;
+    };
+    readonly worker_id: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ScheduleClaimMismatch extends ScheduleClaimMismatch_base {
+}
+export interface CreateScheduleInput {
+    readonly id: Ids.ScheduleId;
+    readonly kind: Schedule.ScheduleKind;
+    readonly targetKind: Schedule.ScheduleTargetKind;
+    readonly addressId?: Ids.AddressId;
+    readonly waitId?: Ids.WaitId;
+    readonly cronExpr?: string;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly nextRunAt: number;
+    readonly idempotencyKey?: string;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface ListSchedulesInput {
+    readonly state?: Schedule.ScheduleState;
+}
+export interface CancelScheduleInput {
+    readonly id: Ids.ScheduleId;
+    readonly cancelledAt: number;
+}
+export interface ClaimDueInput {
+    readonly workerId: string;
+    readonly now: number;
+    readonly claimExpiresAt: number;
+}
+export interface AckScheduleInput {
+    readonly id: Ids.ScheduleId;
+    readonly workerId: string;
+    readonly now: number;
+    readonly nextRunAt?: number;
+}
+export interface ReleaseScheduleInput {
+    readonly id: Ids.ScheduleId;
+    readonly workerId: string;
+    readonly nextAvailableAt: number;
+    readonly error: string;
+}
+export interface Interface {
+    readonly create: (input: CreateScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError>;
+    readonly get: (id: Ids.ScheduleId) => Effect.Effect<Schedule.ScheduleRecord | undefined, ScheduleRepositoryError>;
+    readonly list: (input: ListSchedulesInput) => Effect.Effect<ReadonlyArray<Schedule.ScheduleRecord>, ScheduleRepositoryError>;
+    readonly cancel: (input: CancelScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleNotFound | ScheduleRepositoryError>;
+    readonly claimDue: (input: ClaimDueInput) => Effect.Effect<Schedule.ScheduleRecord | undefined, ScheduleRepositoryError>;
+    readonly ack: (input: AckScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleNotFound | ScheduleClaimMismatch | ScheduleRepositoryError>;
+    readonly release: (input: ReleaseScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleNotFound | ScheduleClaimMismatch | ScheduleRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ScheduleRepository", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Database.Service>;
+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: CreateScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.ScheduleId">) => Effect.Effect<Schedule.ScheduleRecord | undefined, ScheduleRepositoryError, Service>;
+export declare const list: (input: ListSchedulesInput) => Effect.Effect<readonly Schedule.ScheduleRecord[], ScheduleRepositoryError, Service>;
+export declare const cancel: (input: CancelScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError | ScheduleNotFound, Service>;
+export declare const claimDue: (input: ClaimDueInput) => Effect.Effect<Schedule.ScheduleRecord | undefined, ScheduleRepositoryError, Service>;
+export declare const ack: (input: AckScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError | ScheduleNotFound | ScheduleClaimMismatch, Service>;
+export declare const release: (input: ReleaseScheduleInput) => Effect.Effect<Schedule.ScheduleRecord, ScheduleRepositoryError | ScheduleNotFound | ScheduleClaimMismatch, Service>;
+export {};