@relayfx/sdk 0.0.1

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

@@ -0,0 +1,66 @@
+import { Ids, Tool } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const ToolCallRepositoryError_base: Schema.Class<ToolCallRepositoryError, Schema.TaggedStruct<"ToolCallRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolCallRepositoryError extends ToolCallRepositoryError_base {
+}
+declare const ToolCallNotFound_base: Schema.Class<ToolCallNotFound, Schema.TaggedStruct<"ToolCallNotFound", {
+    readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class ToolCallNotFound extends ToolCallNotFound_base {
+}
+declare const DuplicateToolCall_base: Schema.Class<DuplicateToolCall, Schema.TaggedStruct<"DuplicateToolCall", {
+    readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateToolCall extends DuplicateToolCall_base {
+}
+declare const DuplicateToolResult_base: Schema.Class<DuplicateToolResult, Schema.TaggedStruct<"DuplicateToolResult", {
+    readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class DuplicateToolResult extends DuplicateToolResult_base {
+}
+export interface ToolCallRecord {
+    readonly executionId: Ids.ExecutionId;
+    readonly call: Tool.Call;
+    readonly createdAt: number;
+}
+export interface ToolResultRecord {
+    readonly result: Tool.Result;
+    readonly createdAt: number;
+}
+export interface RecordCallInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly call: Tool.Call;
+    readonly createdAt: number;
+}
+export interface RecordResultInput {
+    readonly result: Tool.Result;
+    readonly createdAt: number;
+}
+export interface Interface {
+    readonly recordCall: (input: RecordCallInput) => Effect.Effect<ToolCallRecord, DuplicateToolCall | ToolCallRepositoryError>;
+    readonly getCall: (id: Ids.ToolCallId) => Effect.Effect<ToolCallRecord | undefined, ToolCallRepositoryError>;
+    readonly listCalls: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<ToolCallRecord>, ToolCallRepositoryError>;
+    readonly recordResult: (input: RecordResultInput) => Effect.Effect<ToolResultRecord, ToolCallNotFound | DuplicateToolResult | ToolCallRepositoryError>;
+    readonly getResult: (callId: Ids.ToolCallId) => Effect.Effect<ToolResultRecord | undefined, ToolCallRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/ToolCallRepository", 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 recordCall: (input: RecordCallInput) => Effect.Effect<ToolCallRecord, ToolCallRepositoryError | DuplicateToolCall, Service>;
+export declare const getCall: (id: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<ToolCallRecord | undefined, ToolCallRepositoryError, Service>;
+export declare const listCalls: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<readonly ToolCallRecord[], ToolCallRepositoryError, Service>;
+export declare const recordResult: (input: RecordResultInput) => Effect.Effect<ToolResultRecord, ToolCallRepositoryError | ToolCallNotFound | DuplicateToolResult, Service>;
+export declare const getResult: (callId: string & import("effect/Brand").Brand<"Relay.ToolCallId">) => Effect.Effect<ToolResultRecord | undefined, ToolCallRepositoryError, Service>;
+export {};

package/dist/types/store-sql/workspace/workspace-lease-repository.d.ts

@@ -0,0 +1,87 @@
+import { Ids, Shared, Workspace } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Database from "../database/database-service";
+declare const WorkspaceLeaseRepositoryError_base: Schema.Class<WorkspaceLeaseRepositoryError, Schema.TaggedStruct<"WorkspaceLeaseRepositoryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class WorkspaceLeaseRepositoryError extends WorkspaceLeaseRepositoryError_base {
+}
+declare const DuplicateWorkspaceLease_base: Schema.Class<DuplicateWorkspaceLease, Schema.TaggedStruct<"DuplicateWorkspaceLease", {
+    readonly execution_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 DuplicateWorkspaceLease extends DuplicateWorkspaceLease_base {
+}
+declare const WorkspaceLeaseNotFound_base: Schema.Class<WorkspaceLeaseNotFound, Schema.TaggedStruct<"WorkspaceLeaseNotFound", {
+    readonly execution_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 WorkspaceLeaseNotFound extends WorkspaceLeaseNotFound_base {
+}
+export type WorkspaceLeaseRecord = Workspace.WorkspaceLeaseRecord;
+export type WorkspaceSnapshotRecord = Workspace.WorkspaceSnapshotRecord;
+export interface PlanInput {
+    readonly id: Ids.WorkspaceLeaseId;
+    readonly executionId: Ids.ExecutionId;
+    readonly providerKey: Workspace.WorkspaceProviderKey;
+    readonly resumeStrategy?: Workspace.WorkspaceResumeStrategy;
+    readonly region?: string;
+    readonly request?: Workspace.WorkspaceRequest;
+    readonly metadata?: Shared.Metadata;
+    readonly now: number;
+}
+export interface MarkRunningInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sandboxRef: Ids.WorkspaceRef;
+    readonly updatedAt: number;
+}
+export interface MarkSuspendedInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly updatedAt: number;
+}
+export interface MarkResumedInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sandboxRef?: Ids.WorkspaceRef;
+    readonly updatedAt: number;
+}
+export interface RecordSnapshotInput {
+    readonly id: Ids.WorkspaceSnapshotId;
+    readonly leaseId: Ids.WorkspaceLeaseId;
+    readonly executionId: Ids.ExecutionId;
+    readonly reason: Workspace.WorkspaceSnapshotReason;
+    readonly snapshotRef: Ids.SnapshotRef;
+    readonly metadata?: Shared.Metadata;
+    readonly createdAt: number;
+}
+export interface MarkTerminalInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly metadata?: Shared.Metadata;
+    readonly updatedAt: number;
+}
+export interface Interface {
+    readonly plan: (input: PlanInput) => Effect.Effect<WorkspaceLeaseRecord, DuplicateWorkspaceLease | WorkspaceLeaseRepositoryError>;
+    readonly getByExecution: (id: Ids.ExecutionId) => Effect.Effect<WorkspaceLeaseRecord | undefined, WorkspaceLeaseRepositoryError>;
+    readonly markRunning: (input: MarkRunningInput) => Effect.Effect<WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
+    readonly markSuspended: (input: MarkSuspendedInput) => Effect.Effect<WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
+    readonly markResumed: (input: MarkResumedInput) => Effect.Effect<WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
+    readonly recordSnapshot: (input: RecordSnapshotInput) => Effect.Effect<WorkspaceSnapshotRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
+    readonly markReleased: (input: MarkTerminalInput) => Effect.Effect<WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
+    readonly markFailed: (input: MarkTerminalInput) => Effect.Effect<WorkspaceLeaseRecord, WorkspaceLeaseNotFound | WorkspaceLeaseRepositoryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/store-sql/WorkspaceLeaseRepository", 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 plan: (input: PlanInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | DuplicateWorkspaceLease, Service>;
+export declare const getByExecution: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Workspace.WorkspaceLeaseRecord | undefined, WorkspaceLeaseRepositoryError, Service>;
+export declare const markRunning: (input: MarkRunningInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
+export declare const markSuspended: (input: MarkSuspendedInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
+export declare const markResumed: (input: MarkResumedInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
+export declare const recordSnapshot: (input: RecordSnapshotInput) => Effect.Effect<Workspace.WorkspaceSnapshotRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
+export declare const markReleased: (input: MarkTerminalInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
+export declare const markFailed: (input: MarkTerminalInput) => Effect.Effect<Workspace.WorkspaceLeaseRecord, WorkspaceLeaseRepositoryError | WorkspaceLeaseNotFound, Service>;
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@relayfx/sdk",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types/relay/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./migrations/*": "./dist/migrations/*"
+  },
+  "types": "./dist/types/relay/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir dist --target bun --format esm --external effect --external 'effect/*' --external '@effect/*' --external drizzle-orm --external 'drizzle-orm/*' --external pg && bun scripts/build-types.ts",
+    "lint": "bun --cwd ../.. oxlint packages/relay/src packages/relay/scripts packages/relay/test",
+    "test": "bun --cwd ../.. vitest run packages/relay/test --passWithNoTests",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "dependencies": {
+    "@effect/ai-anthropic": "4.0.0-beta.90",
+    "@effect/ai-openai": "4.0.0-beta.90",
+    "@effect/ai-openai-compat": "4.0.0-beta.90",
+    "@effect/ai-openrouter": "4.0.0-beta.90",
+    "@effect/sql-pg": "4.0.0-beta.90",
+    "drizzle-orm": "1.0.0-rc.3",
+    "effect": "4.0.0-beta.90",
+    "pg": "8.21.0"
+  },
+  "devDependencies": {
+    "@effect/platform-bun": "4.0.0-beta.90",
+    "@effect/vitest": "4.0.0-beta.90",
+    "@relayfx/ai": "0.0.0",
+    "@relayfx/runtime": "0.0.0",
+    "@relayfx/schema": "0.0.0",
+    "@relayfx/store-sql": "0.0.0",
+    "@types/bun": "1.3.13",
+    "typescript": "5.8.2",
+    "vitest": "4.0.16"
+  }
+}