@relayfx/sdk 0.0.1

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

@@ -0,0 +1,2 @@
+export * as LanguageModelRegistration from "./language-model/language-model-registration";
+export declare const aiPackage = "./index";

package/dist/types/ai/language-model/language-model-registration.d.ts

@@ -0,0 +1,89 @@
+import * as Anthropic from "@effect/ai-anthropic";
+import * as OpenAi from "@effect/ai-openai";
+import * as OpenAiCompat from "@effect/ai-openai-compat";
+import * as OpenRouter from "@effect/ai-openrouter";
+import { ModelRegistry } from "@batonfx/core";
+import { Config, Effect, Layer, Redacted } from "effect";
+export interface RegistrationOptions {
+    readonly registrationKey?: string;
+    readonly metadata?: ModelRegistry.Metadata;
+}
+export interface OpenAiInput extends RegistrationOptions {
+    readonly model: string;
+    readonly config?: Omit<typeof OpenAi.OpenAiLanguageModel.Config.Service, "model">;
+}
+export interface AnthropicInput extends RegistrationOptions {
+    readonly model: string;
+    readonly config?: Omit<typeof Anthropic.AnthropicLanguageModel.Config.Service, "model">;
+}
+export interface OpenRouterInput extends RegistrationOptions {
+    readonly model: string;
+    readonly config?: Omit<typeof OpenRouter.OpenRouterLanguageModel.Config.Service, "model">;
+}
+export interface OpenAiCompatibleInput extends RegistrationOptions {
+    readonly provider?: string;
+    readonly model: string;
+    readonly config?: Omit<typeof OpenAiCompat.OpenAiLanguageModel.Config.Service, "model">;
+}
+export declare const openAi: (input: OpenAiInput) => Effect.Effect<ModelRegistry.Registration, never, OpenAi.OpenAiClient.OpenAiClient>;
+export declare const anthropic: (input: AnthropicInput) => Effect.Effect<ModelRegistry.Registration, never, Anthropic.AnthropicClient.AnthropicClient>;
+export declare const openRouter: (input: OpenRouterInput) => Effect.Effect<ModelRegistry.Registration, never, OpenRouter.OpenRouterClient.OpenRouterClient>;
+export declare const openAiCompatible: (input: OpenAiCompatibleInput) => Effect.Effect<ModelRegistry.Registration, never, OpenAiCompat.OpenAiClient.OpenAiClient>;
+export declare const openAiClientLayerConfig: (options?: {
+    readonly apiKey?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly apiUrl?: Config.Config<string> | undefined;
+    readonly organizationId?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly projectId?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly transformClient?: ((client: import("effect/unstable/http/HttpClient").HttpClient) => import("effect/unstable/http/HttpClient").HttpClient) | undefined;
+}) => Layer.Layer<OpenAi.OpenAiClient.OpenAiClient, Config.ConfigError, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const anthropicClientLayerConfig: (options?: {
+    readonly apiKey?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly apiUrl?: Config.Config<string> | undefined;
+    readonly apiVersion?: Config.Config<string> | undefined;
+    readonly transformClient?: ((client: import("effect/unstable/http/HttpClient").HttpClient) => import("effect/unstable/http/HttpClient").HttpClient) | undefined;
+}) => Layer.Layer<Anthropic.AnthropicClient.AnthropicClient, Config.ConfigError, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const openRouterClientLayerConfig: (options?: {
+    readonly apiKey?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly apiUrl?: Config.Config<string> | undefined;
+    readonly siteReferrer?: Config.Config<string> | undefined;
+    readonly siteTitle?: Config.Config<string> | undefined;
+    readonly transformClient?: ((client: import("effect/unstable/http/HttpClient").HttpClient) => import("effect/unstable/http/HttpClient").HttpClient) | undefined;
+}) => Layer.Layer<OpenRouter.OpenRouterClient.OpenRouterClient, Config.ConfigError, import("effect/unstable/http/HttpClient").HttpClient>;
+export declare const openAiCompatibleClientLayerConfig: (options?: {
+    readonly apiKey?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly apiUrl?: Config.Config<string> | undefined;
+    readonly organizationId?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly projectId?: Config.Config<Redacted.Redacted<string> | undefined> | undefined;
+    readonly transformClient?: ((client: import("effect/unstable/http/HttpClient").HttpClient) => import("effect/unstable/http/HttpClient").HttpClient) | undefined;
+}) => Layer.Layer<OpenAiCompat.OpenAiClient.OpenAiClient, Config.ConfigError, import("effect/unstable/http/HttpClient").HttpClient>;
+export interface WithOpenAiOptions extends OpenAiInput {
+    readonly apiKey: Config.Config<Redacted.Redacted<string>>;
+    readonly clientConfig?: Omit<NonNullable<Parameters<typeof OpenAi.OpenAiClient.layerConfig>[0]>, "apiKey">;
+}
+export interface WithAnthropicOptions extends AnthropicInput {
+    readonly apiKey: Config.Config<Redacted.Redacted<string>>;
+    readonly clientConfig?: Omit<NonNullable<Parameters<typeof Anthropic.AnthropicClient.layerConfig>[0]>, "apiKey">;
+}
+export interface WithOpenRouterOptions extends OpenRouterInput {
+    readonly apiKey: Config.Config<Redacted.Redacted<string>>;
+    readonly clientConfig?: Omit<NonNullable<Parameters<typeof OpenRouter.OpenRouterClient.layerConfig>[0]>, "apiKey">;
+}
+export interface WithOpenAiCompatibleOptions extends OpenAiCompatibleInput {
+    readonly apiKey: Config.Config<Redacted.Redacted<string>>;
+    readonly clientConfig?: Omit<NonNullable<Parameters<typeof OpenAiCompat.OpenAiClient.layerConfig>[0]>, "apiKey">;
+}
+export declare const withOpenAi: (options: WithOpenAiOptions) => Layer.Layer<ModelRegistry.Service, Config.ConfigError, never>;
+export declare const withAnthropic: (options: WithAnthropicOptions) => Layer.Layer<ModelRegistry.Service, Config.ConfigError, never>;
+export declare const withOpenRouter: (options: WithOpenRouterOptions) => Layer.Layer<ModelRegistry.Service, Config.ConfigError, never>;
+export declare const withOpenAiCompatible: (options: WithOpenAiCompatibleOptions) => Layer.Layer<ModelRegistry.Service, Config.ConfigError, never>;
+export interface DeterministicInput extends RegistrationOptions {
+    readonly provider?: string;
+    readonly model?: string;
+}
+export declare const deterministicModel: (input?: DeterministicInput) => Effect.Effect<ModelRegistry.Registration, never, never>;
+export declare const withDeterministic: (input?: DeterministicInput) => Layer.Layer<ModelRegistry.Service, never, never>;
+export interface WithOpenAiOrDeterministicOptions extends WithOpenAiOptions {
+    readonly fallbackModel: string;
+    readonly fallbackProvider?: string;
+}
+export declare const withOpenAiOrDeterministic: (options: WithOpenAiOrDeterministicOptions) => Layer.Layer<ModelRegistry.Service, never, never>;

package/dist/types/relay/adapter-outbox.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from "effect";
+import * as Client from "./client";
+import * as Operation from "./operation";
+export interface Interface {
+    readonly claim: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, Client.ClientError>;
+    readonly ack: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, Client.ClientError>;
+    readonly release: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, Client.ClientError>;
+    readonly submitInbound: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, Client.ClientError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/AdapterOutbox", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Client.Service>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const claim: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, Client.ClientError, Service>;
+export declare const ack: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, Client.ClientError, Service>;
+export declare const release: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, Client.ClientError, Service>;
+export declare const submitInbound: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, Client.ClientError, Service>;
+export {};

package/dist/types/relay/client.d.ts

@@ -0,0 +1,102 @@
+import { AddressBook, AgentRegistry, EventLog, ExecutionService, WaitService } from "../runtime/index";
+import { Address, Agent, Content, Envelope, Execution, Ids, Shared } from "../schema/index";
+import { ClusterRegistryRepository, EnvelopeRepository, ExecutionRepository, ScheduleRepository } from "../store-sql/index";
+import { Context, Effect, Layer, Schema, Stream } from "effect";
+import { Sharding, ShardingConfig } from "effect/unstable/cluster";
+import * as Operation from "./operation";
+declare const ClientError_base: Schema.Class<ClientError, Schema.TaggedStruct<"ClientError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ClientError extends ClientError_base {
+}
+export interface StartExecutionByAddressInput {
+    readonly address_id: Ids.AddressId;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly idempotency_key: Shared.NonEmptyString;
+    readonly execution_id?: Ids.ExecutionId;
+    readonly event_sequence?: Execution.ExecutionEventSequence;
+    readonly started_at: Shared.TimestampMillis;
+    readonly completed_at: Shared.TimestampMillis;
+    readonly wait_id?: Ids.WaitId;
+    readonly metadata?: Shared.Metadata;
+}
+export interface StartExecutionByAgentDefinitionInput {
+    readonly root_address_id: Ids.AddressId;
+    readonly agent_definition_id: Ids.AgentDefinitionId;
+    readonly input?: ReadonlyArray<Content.Part>;
+    readonly idempotency_key: Shared.NonEmptyString;
+    readonly execution_id?: Ids.ExecutionId;
+    readonly event_sequence?: Execution.ExecutionEventSequence;
+    readonly started_at: Shared.TimestampMillis;
+    readonly completed_at: Shared.TimestampMillis;
+    readonly wait_id?: Ids.WaitId;
+    readonly metadata?: Shared.Metadata;
+}
+export interface Interface {
+    readonly registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError>;
+    readonly getAgentDefinition: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError>;
+    readonly listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError>;
+    readonly listAgentDefinitionRevisions: (id: Ids.AgentDefinitionId) => Effect.Effect<Agent.DefinitionRevisionList, ClientError>;
+    readonly registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError>;
+    readonly getAddressBookRoute: (id: Ids.AddressId) => Effect.Effect<Address.RouteRecord | undefined, ClientError>;
+    readonly listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError>;
+    readonly startExecution: (input: Operation.StartExecutionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError>;
+    readonly startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<Operation.StartExecutionResult, ClientError>;
+    readonly startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError>;
+    readonly cancelExecution: (input: Operation.CancelExecutionInput) => Effect.Effect<Operation.CancelExecutionAccepted, ClientError>;
+    readonly getExecution: (id: Ids.ExecutionId) => Effect.Effect<Execution.Execution | undefined, ClientError>;
+    readonly listExecutions: (input: Operation.ListExecutionsInput) => Effect.Effect<Operation.ListExecutionsResult, ClientError>;
+    readonly listWaits: (input: Operation.ListWaitsInput) => Effect.Effect<ReadonlyArray<Operation.WaitView>, ClientError>;
+    readonly replayExecution: (input: Operation.ReplayExecutionInput) => Effect.Effect<Operation.ReplayExecutionResult, ClientError>;
+    readonly listRunners: () => Effect.Effect<Operation.ListRunnersResult, ClientError>;
+    readonly routeExecution: (executionId: Ids.ExecutionId) => Effect.Effect<Operation.RouteExecutionResult, ClientError>;
+    readonly send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError>;
+    readonly streamExecution: (input: Operation.StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError>;
+    readonly wake: (input: Operation.WakeInput) => Effect.Effect<Operation.WakeAccepted, ClientError>;
+    readonly listPendingApprovals: (input: Operation.ListPendingApprovalsInput) => Effect.Effect<Operation.PendingToolApprovalList, ClientError>;
+    readonly resolveToolApproval: (input: Operation.ResolveToolApprovalInput) => Effect.Effect<Operation.WakeAccepted, ClientError>;
+    readonly submitInboundEnvelope: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, ClientError>;
+    readonly spawnChildRun: (input: Execution.SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError>;
+    readonly claimEnvelopeReady: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, ClientError>;
+    readonly ackEnvelopeReady: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, ClientError>;
+    readonly releaseEnvelopeReady: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, ClientError>;
+    readonly createSchedule: (input: Operation.CreateScheduleInput) => Effect.Effect<Operation.CreateScheduleResult, ClientError>;
+    readonly cancelSchedule: (input: Operation.CancelScheduleInput) => Effect.Effect<Operation.CancelScheduleResult, ClientError>;
+    readonly listSchedules: (input: Operation.ListSchedulesInput) => Effect.Effect<Operation.ListSchedulesResult, ClientError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/Client", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromRuntime: Layer.Layer<Service, never, AgentRegistry.Service | AddressBook.Service | ExecutionService.Service | WaitService.Service | EventLog.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ClusterRegistryRepository.Service | ScheduleRepository.Service | Sharding.Sharding | ShardingConfig.ShardingConfig>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const registerAgentDefinition: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, ClientError, Service>;
+export declare const getAgentDefinition: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRecord | undefined, ClientError, Service>;
+export declare const listAgentDefinitions: () => Effect.Effect<Agent.DefinitionList, ClientError, Service>;
+export declare const listAgentDefinitionRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRevisionList, ClientError, Service>;
+export declare const registerAddressBookRoute: (input: Address.RegisterRoutePayload) => Effect.Effect<Address.RouteRegistered, ClientError, Service>;
+export declare const getAddressBookRoute: (id: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Address.RouteRecord | undefined, ClientError, Service>;
+export declare const listAddressBookRoutes: () => Effect.Effect<Address.RouteList, ClientError, Service>;
+export declare const startExecution: (input: Operation.StartExecutionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
+export declare const startExecutionByAddress: (input: StartExecutionByAddressInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
+export declare const startExecutionByAgentDefinition: (input: StartExecutionByAgentDefinitionInput) => Effect.Effect<Operation.StartExecutionResult, ClientError, Service>;
+export declare const cancelExecution: (input: Operation.CancelExecutionInput) => Effect.Effect<Operation.CancelExecutionAccepted, ClientError, Service>;
+export declare const getExecution: (id: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Execution.Execution | undefined, ClientError, Service>;
+export declare const listExecutions: (input: Operation.ListExecutionsInput) => Effect.Effect<Operation.ListExecutionsResult, ClientError, Service>;
+export declare const listWaits: (input: Operation.ListWaitsInput) => Effect.Effect<readonly Operation.WaitView[], ClientError, Service>;
+export declare const replayExecution: (input: Operation.ReplayExecutionInput) => Effect.Effect<Operation.ReplayExecutionResult, ClientError, Service>;
+export declare const listRunners: () => Effect.Effect<Operation.ListRunnersResult, ClientError, Service>;
+export declare const routeExecution: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Operation.RouteExecutionResult, ClientError, Service>;
+export declare const send: (input: Envelope.SendInput) => Effect.Effect<Envelope.EnvelopeAccepted, ClientError, Service>;
+export declare const streamExecution: (input: Operation.StreamExecutionInput) => Stream.Stream<Execution.ExecutionEvent, ClientError, Service>;
+export declare const wake: (input: Operation.WakeInput) => Effect.Effect<Operation.WakeAccepted, ClientError, Service>;
+export declare const listPendingApprovals: (input: Operation.ListPendingApprovalsInput) => Effect.Effect<Operation.PendingToolApprovalList, ClientError, Service>;
+export declare const resolveToolApproval: (input: Operation.ResolveToolApprovalInput) => Effect.Effect<Operation.WakeAccepted, ClientError, Service>;
+export declare const submitInboundEnvelope: (input: Operation.SubmitInboundEnvelopeInput) => Effect.Effect<Operation.SubmitInboundEnvelopeAccepted, ClientError, Service>;
+export declare const spawnChildRun: (input: Execution.SpawnChildRunInput) => Effect.Effect<Execution.ChildRunAccepted, ClientError, Service>;
+export declare const claimEnvelopeReady: (input: Operation.ClaimEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyLease | null, ClientError, Service>;
+export declare const ackEnvelopeReady: (input: Operation.AckEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyAcked, ClientError, Service>;
+export declare const releaseEnvelopeReady: (input: Operation.ReleaseEnvelopeReadyInput) => Effect.Effect<Operation.EnvelopeReadyReleased, ClientError, Service>;
+export declare const createSchedule: (input: Operation.CreateScheduleInput) => Effect.Effect<Operation.CreateScheduleResult, ClientError, Service>;
+export declare const cancelSchedule: (input: Operation.CancelScheduleInput) => Effect.Effect<Operation.CancelScheduleResult, ClientError, Service>;
+export declare const listSchedules: (input: Operation.ListSchedulesInput) => Effect.Effect<Operation.ListSchedulesResult, ClientError, Service>;
+export {};

package/dist/types/relay/database.d.ts

@@ -0,0 +1,11 @@
+import * as StoreSql from "../store-sql/index";
+export type Drizzle = StoreSql.Database.Drizzle;
+export type PgTimestamp = StoreSql.Database.PgTimestamp;
+export type DatabaseError = StoreSql.Database.DatabaseError;
+export declare const Service: typeof StoreSql.Database.Service;
+export declare const layerFromPgClient: import("effect/Layer").Layer<StoreSql.Database.Service, never, import("@effect/sql-pg/PgClient").PgClient>;
+export declare const testLayer: (db: StoreSql.Database.Drizzle) => import("effect/Layer").Layer<StoreSql.Database.Service, never, never>;
+export declare const check: () => import("effect/Effect").Effect<void, import("drizzle-orm/effect-core").EffectDrizzleQueryError, StoreSql.Database.Service>;
+export declare const pgTypeParsers: {
+    getTypeParser: (typeId: number, format?: "text" | "binary") => any;
+};

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

@@ -0,0 +1,10 @@
+export * as AdapterOutbox from "./adapter-outbox";
+export * as Client from "./client";
+export * as Database from "./database";
+export * as Operation from "./operation";
+export { Address, Agent, Content, Envelope, Execution, Ids, Schedule, Shared, Tool } from "../schema/index";
+export { AddressBook, AddressResolution, AgentLoop, AgentRegistry, ArtifactStore, BlobStore, ChildRunService, EnvelopeService, EventLog, ExecutionEntity, ExecutionService, ExecutionWorkflow, LanguageModelService, ModelCallPolicy, PromptAssembler, SchedulerService, ToolRuntime, WaitService, } from "../runtime/index";
+export { RunnerRuntime } from "../runtime/index";
+export { LanguageModelRegistration } from "../ai/index";
+export { RelaySchema } from "../store-sql/index";
+export declare const relayPackage = "@relayfx/sdk";