@relayfx/test 0.3.1 → 0.3.2

package/dist/types/runtime/state/state-tools.d.ts

@@ -1,5 +0,0 @@
-import { Agent } from "../../schema/index";
-import type { RegisteredTool } from "../tool/tool-runtime-service";
-import { type Interface } from "./execution-state-service";
-export declare const enabled: (agent: Agent.Definition) => boolean;
-export declare const registeredTools: (state: Interface) => ReadonlyArray<RegisteredTool>;

package/dist/types/runtime/tool/tool-input-schema-digest.d.ts

@@ -1,6 +0,0 @@
-import { Tool } from "../../schema/index";
-import { Crypto, Effect } from "effect";
-export declare const digestInputSchema: (inputSchema: import("effect/Schema").Json) => Effect.Effect<string, import("effect/PlatformError").PlatformError, Crypto.Crypto>;
-export declare const digestDefinitions: (definitions: readonly Tool.Definition[], toolNames: readonly string[]) => Effect.Effect<{
-    [k: string]: string;
-}, import("effect/PlatformError").PlatformError, Crypto.Crypto>;

package/dist/types/runtime/tool/tool-runtime-service.d.ts

@@ -1,162 +0,0 @@
-import { Execution, Ids, Shared, Tool } from "../../schema/index";
-import { ToolCallRepository } from "@relayfx/store-sql/portable";
-import { Tool as AiTool, Toolkit } from "effect/unstable/ai";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
-import { Service as WaitServiceService } from "../wait/wait-service";
-declare const ToolNotRegistered_base: Schema.Class<ToolNotRegistered, Schema.TaggedStruct<"ToolNotRegistered", {
-    readonly tool_name: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolNotRegistered extends ToolNotRegistered_base {
-}
-declare const ToolPermissionDenied_base: Schema.Class<ToolPermissionDenied, Schema.TaggedStruct<"ToolPermissionDenied", {
-    readonly tool_name: Schema.String;
-    readonly permission_name: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolPermissionDenied extends ToolPermissionDenied_base {
-}
-declare const ToolInputInvalid_base: Schema.Class<ToolInputInvalid, Schema.TaggedStruct<"ToolInputInvalid", {
-    readonly tool_name: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolInputInvalid extends ToolInputInvalid_base {
-}
-declare const ToolExecutionFailed_base: Schema.Class<ToolExecutionFailed, Schema.TaggedStruct<"ToolExecutionFailed", {
-    readonly tool_name: Schema.String;
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolExecutionFailed extends ToolExecutionFailed_base {
-}
-declare const ToolExecutionWaitRequested_base: Schema.Class<ToolExecutionWaitRequested, Schema.TaggedStruct<"ToolExecutionWaitRequested", {
-    readonly tool_name: Schema.String;
-    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolExecutionWaitRequested extends ToolExecutionWaitRequested_base {
-}
-declare const ToolRuntimeError_base: Schema.Class<ToolRuntimeError, Schema.TaggedStruct<"ToolRuntimeError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ToolRuntimeError extends ToolRuntimeError_base {
-}
-export interface ToolExecutionContext {
-    readonly executionId: Ids.ExecutionId;
-    readonly call: Tool.Call;
-    readonly permissions: ReadonlyArray<Tool.Permission>;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-    readonly idempotencyKey: string;
-}
-export interface ToolCallInfoData extends ToolExecutionContext {
-}
-declare const ToolCallInfo_base: Context.ServiceClass<ToolCallInfo, "@relayfx/runtime/tool/tool-runtime-service/ToolCallInfo", ToolCallInfoData>;
-export declare class ToolCallInfo extends ToolCallInfo_base {
-}
-export interface RegisteredTool {
-    readonly definition: Tool.Definition;
-    readonly tool: AiTool.Any;
-    readonly placement?: Tool.Placement | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string>;
-    readonly validateInput?: (input: Shared.JsonValue) => Effect.Effect<void, ToolInputInvalid>;
-    readonly run?: ((input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>) | undefined;
-}
-export interface ToolOptions<Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>> {
-    readonly description: string;
-    readonly input: Input;
-    readonly output: Output;
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-    readonly placement?: Tool.Placement | undefined;
-    readonly run: (input: Input["Type"], context: ToolExecutionContext) => Effect.Effect<Output["Type"], ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, ToolCallInfo>;
-}
-export interface DynamicToolOptions {
-    readonly description: string;
-    readonly inputSchema: Shared.JsonValue;
-    readonly outputSchema: Shared.JsonValue;
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-    readonly placement?: Tool.Placement | undefined;
-    readonly run: (input: Shared.JsonValue, context: ToolExecutionContext) => Effect.Effect<Shared.JsonValue, ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError>;
-}
-export interface ToolkitToolOptions {
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-    readonly placement?: Tool.Placement | undefined;
-}
-export type ToolkitRegistrationOptions = ToolkitToolOptions | ((tool: AiTool.Any) => ToolkitToolOptions);
-export interface RunInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly call: Tool.Call;
-    readonly permissions: ReadonlyArray<Tool.Permission>;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-    readonly extraTools?: ReadonlyArray<RegisteredTool>;
-    readonly transformResult?: (result: Tool.Result) => Effect.Effect<Tool.Result, ToolRuntimeError>;
-}
-export interface Interface {
-    readonly register: (tool: RegisteredTool) => Effect.Effect<void>;
-    readonly definitions: Effect.Effect<ReadonlyArray<Tool.Definition>>;
-    readonly registeredTools: Effect.Effect<ReadonlyArray<RegisteredTool>>;
-    readonly run: (input: RunInput) => Effect.Effect<Tool.Result, ToolNotRegistered | ToolPermissionDenied | ToolInputInvalid | ToolExecutionFailed | ToolExecutionWaitRequested | ToolRuntimeError, never>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/tool/tool-runtime-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const toolFromRegistered: (tool: RegisteredTool) => AiTool.Any;
-export declare const toolsFromToolkit: {
-    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.WithHandler<Tools>, options?: ToolkitRegistrationOptions): ReadonlyArray<RegisteredTool>;
-    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.WithHandler<Tools>) => ReadonlyArray<RegisteredTool>;
-};
-export declare const tool: {
-    <const Name extends string, Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(name: Name, options: ToolOptions<Input, Output>): RegisteredTool;
-    <Input extends Schema.ConstraintCodec<unknown, unknown, never, never>, Output extends Schema.ConstraintCodec<unknown, unknown, never, never>>(options: ToolOptions<Input, Output>): <const Name extends string>(name: Name) => RegisteredTool;
-};
-export declare const dynamicTool: {
-    <const Name extends string>(name: Name, options: DynamicToolOptions): RegisteredTool;
-    (options: DynamicToolOptions): <const Name extends string>(name: Name) => RegisteredTool;
-};
-export interface PlacedToolOptions {
-    readonly permissions?: ReadonlyArray<Tool.Permission> | undefined;
-    readonly requiredPermissions?: ReadonlyArray<string> | undefined;
-    readonly requirements?: ReadonlyArray<Tool.RuntimeRequirement> | undefined;
-    readonly needsApproval?: boolean | undefined;
-    readonly metadata?: Shared.Metadata | undefined;
-}
-export declare const clientTool: {
-    (modelTool: AiTool.Any, options?: PlacedToolOptions): RegisteredTool;
-    (options?: PlacedToolOptions): (modelTool: AiTool.Any) => RegisteredTool;
-};
-export declare const remoteTool: {
-    (modelTool: AiTool.Any, options: PlacedToolOptions & {
-        readonly queue: Tool.PlacementKey;
-    }): RegisteredTool;
-    (options: PlacedToolOptions & {
-        readonly queue: Tool.PlacementKey;
-    }): (modelTool: AiTool.Any) => RegisteredTool;
-};
-export declare const layer: (initialTools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<Service, never, ToolCallRepository.Service | EventLogService | WaitServiceService>;
-export declare const layerFromToolkit: {
-    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<Service, never, ToolCallRepository.Service | EventLogService | WaitServiceService | AiTool.HandlersFor<Tools>>;
-    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<Service, never, ToolCallRepository.Service | EventLogService | WaitServiceService | AiTool.HandlersFor<Tools>>;
-};
-export declare const memoryLayer: (tools?: ReadonlyArray<RegisteredTool>) => Layer.Layer<Service, never, never>;
-export declare const memoryLayerFromToolkit: {
-    <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>, options?: ToolkitRegistrationOptions): Layer.Layer<Service, never, Exclude<AiTool.HandlersFor<Tools>, ToolCallRepository.Service | EventLogService | WaitServiceService>>;
-    (options?: ToolkitRegistrationOptions): <Tools extends Record<string, AiTool.Any>>(toolkit: Toolkit.Toolkit<Tools>) => Layer.Layer<Service, never, Exclude<AiTool.HandlersFor<Tools>, ToolCallRepository.Service | EventLogService | WaitServiceService>>;
-};
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const register: (registeredTool: RegisteredTool) => Effect.Effect<void, never, Service>;
-export declare const definitions: () => Effect.Effect<readonly Tool.Definition[], never, Service>;
-export declare const registeredTools: () => Effect.Effect<readonly RegisteredTool[], never, Service>;
-export declare const run: (input: RunInput) => Effect.Effect<Tool.Result, ToolExecutionFailed | ToolExecutionWaitRequested | ToolInputInvalid | ToolNotRegistered | ToolPermissionDenied | ToolRuntimeError, Service>;
-export {};

package/dist/types/runtime/tool/tool-transition-coordinator.d.ts

@@ -1,13 +0,0 @@
-import { Context, Effect, Layer } from "effect";
-import { SqlClient } from "effect/unstable/sql/SqlClient";
-import type { SqlError } from "effect/unstable/sql/SqlError";
-export interface Interface {
-    readonly coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError, R>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/tool/tool-transition-coordinator/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const memoryLayer: Layer.Layer<Service, never, never>;
-export declare const sqlLayer: Layer.Layer<Service, never, SqlClient>;
-export declare const coordinate: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E | SqlError, R | Service>;
-export {};

package/dist/types/runtime/topic/publish-to-topic-tool.d.ts

@@ -1,24 +0,0 @@
-import { Ids } from "../../schema/index";
-import { Schema } from "effect";
-import type { RegisteredTool } from "../tool/tool-runtime-service";
-import type { Interface as TopicInterface } from "./topic-service";
-export declare const toolName = "publish_to_topic";
-export declare const permissionName = "relay.topic.publish";
-export declare const Input: Schema.Struct<{
-    readonly topic: Schema.String;
-    readonly content: Schema.Union<readonly [Schema.String, Schema.$Array<Schema.Struct<{
-        readonly type: Schema.Literal<"text">;
-        readonly text: Schema.String;
-        readonly provider_options: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    }>>]>;
-}>;
-export declare const Output: Schema.Struct<{
-    readonly envelope_id: Schema.String;
-    readonly subscriber_count: Schema.Int;
-}>;
-export interface Config {
-    readonly topics: TopicInterface;
-    readonly from: Ids.AddressId;
-}
-export declare const registeredTool: (config: Config) => RegisteredTool;

package/dist/types/runtime/topic/topic-service.d.ts

@@ -1,50 +0,0 @@
-import { Content, Ids, Shared } from "../../schema/index";
-import { EnvelopeRepository, ExecutionRepository, TopicRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as InboxServiceService } from "../inbox/inbox-service";
-declare const TopicServiceError_base: Schema.Class<TopicServiceError, Schema.TaggedStruct<"TopicServiceError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class TopicServiceError extends TopicServiceError_base {
-}
-export interface SubscribeInput {
-    readonly topicAddressId: Ids.AddressId;
-    readonly subscriberExecutionId: Ids.ExecutionId;
-    readonly metadata?: Shared.Metadata;
-}
-export interface UnsubscribeInput {
-    readonly topicAddressId: Ids.AddressId;
-    readonly subscriberExecutionId: Ids.ExecutionId;
-}
-export interface PublishInput {
-    readonly topicAddressId: Ids.AddressId;
-    readonly from: Ids.AddressId;
-    readonly content: ReadonlyArray<Content.Part>;
-    readonly metadata?: Shared.Metadata;
-    readonly idempotencyKey?: string;
-}
-export interface PublishResult {
-    readonly envelope_id: Ids.EnvelopeId;
-    readonly subscriber_count: number;
-}
-export interface ListInput {
-    readonly topicAddressId?: Ids.AddressId;
-    readonly subscriberExecutionId?: Ids.ExecutionId;
-}
-export interface Interface {
-    readonly subscribe: (input: SubscribeInput) => Effect.Effect<TopicRepository.Subscription, TopicServiceError>;
-    readonly unsubscribe: (input: UnsubscribeInput) => Effect.Effect<void, TopicServiceError>;
-    readonly publish: (input: PublishInput) => Effect.Effect<PublishResult, TopicServiceError>;
-    readonly list: (input: ListInput) => Effect.Effect<ReadonlyArray<TopicRepository.Subscription>, TopicServiceError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/topic/topic-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | ExecutionRepository.Service | TopicRepository.Service | InboxServiceService>;
-export declare const memoryLayer: Layer.Layer<Service, never, EnvelopeRepository.Service | ExecutionRepository.Service | InboxServiceService>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const subscribe: (input: SubscribeInput) => Effect.Effect<TopicRepository.Subscription, TopicServiceError, Service>;
-export declare const unsubscribe: (input: UnsubscribeInput) => Effect.Effect<void, TopicServiceError, Service>;
-export declare const publish: (input: PublishInput) => Effect.Effect<PublishResult, TopicServiceError, Service>;
-export declare const list: (input: ListInput) => Effect.Effect<readonly TopicRepository.Subscription[], TopicServiceError, Service>;
-export {};

package/dist/types/runtime/wait/wait-service.d.ts

@@ -1,81 +0,0 @@
-import { Envelope, Execution, Ids, Shared } from "../../schema/index";
-import { EnvelopeRepository, ScheduleRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
-declare const WaitNotFound_base: Schema.Class<WaitNotFound, Schema.TaggedStruct<"WaitNotFound", {
-    readonly wait_id: Schema.brand<Schema.String, "Relay.WaitId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WaitId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class WaitNotFound extends WaitNotFound_base {
-}
-declare const WaitDefinitionMissing_base: Schema.Class<WaitDefinitionMissing, Schema.TaggedStruct<"WaitDefinitionMissing", {
-    readonly envelope_id: Schema.brand<Schema.String, "Relay.EnvelopeId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.EnvelopeId">;
-    };
-}>, import("effect/Cause").YieldableError>;
-export declare class WaitDefinitionMissing extends WaitDefinitionMissing_base {
-}
-declare const WaitServiceError_base: Schema.Class<WaitServiceError, Schema.TaggedStruct<"WaitServiceError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class WaitServiceError extends WaitServiceError_base {
-}
-export interface CreateWaitInput {
-    readonly waitId: Ids.WaitId;
-    readonly envelope: Envelope.Envelope;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-}
-export interface CreateDetachedWaitInput {
-    readonly waitId: Ids.WaitId;
-    readonly executionId: Ids.ExecutionId;
-    readonly mode: Envelope.WaitMode;
-    readonly correlationKey?: string;
-    readonly metadata?: Shared.Metadata;
-    readonly timeout?: string;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-}
-export interface WakeInput {
-    readonly waitId: Ids.WaitId;
-    readonly resolvedAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly metadata?: Shared.Metadata;
-}
-export interface TimeoutInput {
-    readonly waitId: Ids.WaitId;
-    readonly timedOutAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly metadata?: Shared.Metadata;
-}
-export interface CancelWaitInput {
-    readonly waitId: Ids.WaitId;
-    readonly cancelledAt: number;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly metadata?: Shared.Metadata;
-}
-export interface WaitTransition {
-    readonly wait: EnvelopeRepository.WaitRecord;
-    readonly transitioned: boolean;
-}
-export interface Interface {
-    readonly create: (input: CreateWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitDefinitionMissing | WaitServiceError>;
-    readonly createDetached: (input: CreateDetachedWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitServiceError>;
-    readonly get: (id: Ids.WaitId) => Effect.Effect<EnvelopeRepository.WaitRecord | undefined, WaitServiceError>;
-    readonly wake: (input: WakeInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
-    readonly timeout: (input: TimeoutInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
-    readonly cancel: (input: CancelWaitInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/wait/wait-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, EnvelopeRepository.Service | ScheduleRepository.Service | EventLogService>;
-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: CreateWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitDefinitionMissing | WaitServiceError, Service>;
-export declare const createDetached: (input: CreateDetachedWaitInput) => Effect.Effect<EnvelopeRepository.WaitRecord, WaitServiceError, Service>;
-export declare const get: (id: string & import("effect/Brand").Brand<"Relay.WaitId">) => Effect.Effect<EnvelopeRepository.WaitRecord | undefined, WaitServiceError, Service>;
-export declare const wake: (input: WakeInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError, Service>;
-export declare const timeout: (input: TimeoutInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError, Service>;
-export declare const cancel: (input: CancelWaitInput) => Effect.Effect<WaitTransition, WaitNotFound | WaitServiceError, Service>;
-export {};

package/dist/types/runtime/wait/wait-signal.d.ts

@@ -1,25 +0,0 @@
-import { Ids } from "../../schema/index";
-import { ExecutionRepository } from "@relayfx/store-sql/portable";
-import { Effect, Schema } from "effect";
-import { ExecutionWorkflowFailed } from "../workflow/execution-workflow";
-import type { SignalWaitInput, WaitSignalState } from "../workflow/execution-workflow";
-export interface ExecutionSignalClient {
-    readonly signalWait: (input: SignalWaitInput) => Effect.Effect<void, {
-        readonly _tag: string;
-    }>;
-}
-declare const WaitSignalError_base: Schema.Class<WaitSignalError, Schema.TaggedStruct<"WaitSignalError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class WaitSignalError extends WaitSignalError_base {
-}
-export type ExecutionClientFactory = (executionId: Ids.ExecutionId) => ExecutionSignalClient;
-export interface SignalWorkflowWaitInput {
-    readonly makeExecutionClient: ExecutionClientFactory;
-    readonly executionId: Ids.ExecutionId;
-    readonly waitId: Ids.WaitId;
-    readonly state: WaitSignalState;
-    readonly signaledAt: number;
-}
-export declare const signalWorkflowWait: (input: SignalWorkflowWaitInput) => Effect.Effect<void, WaitSignalError | ExecutionWorkflowFailed, ExecutionRepository.Service>;
-export {};

package/dist/types/runtime/workflow/activity-version-registry.d.ts

@@ -1,93 +0,0 @@
-import { Crypto, Effect, Schema } from "effect";
-export declare const ActivityManifestEntry: Schema.Struct<{
-    readonly name: Schema.String;
-    readonly signature_hash: Schema.String;
-}>;
-export interface ActivityManifestEntry extends Schema.Schema.Type<typeof ActivityManifestEntry> {
-}
-export declare const ActivityManifest: Schema.Struct<{
-    readonly version: Schema.Literal<1>;
-    readonly generated_from: Schema.String;
-    readonly hash_algorithm: Schema.Literal<"sha256-json-schema-v1">;
-    readonly activities: Schema.$Array<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly signature_hash: Schema.String;
-    }>>;
-}>;
-export interface ActivityManifest extends Schema.Schema.Type<typeof ActivityManifest> {
-}
-export declare const ActivityManifestChange: Schema.Struct<{
-    readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
-    readonly name: Schema.String;
-    readonly baseline_hash: Schema.optionalKey<Schema.String>;
-    readonly current_hash: Schema.optionalKey<Schema.String>;
-}>;
-export interface ActivityManifestChange extends Schema.Schema.Type<typeof ActivityManifestChange> {
-}
-export declare const ActivityManifestGuardResult: Schema.Struct<{
-    readonly status: Schema.Literals<readonly ["pass", "fail"]>;
-    readonly waiting_executions: Schema.Int;
-    readonly breaking_changes: Schema.$Array<Schema.Struct<{
-        readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
-        readonly name: Schema.String;
-        readonly baseline_hash: Schema.optionalKey<Schema.String>;
-        readonly current_hash: Schema.optionalKey<Schema.String>;
-    }>>;
-    readonly additive_changes: Schema.$Array<Schema.Struct<{
-        readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
-        readonly name: Schema.String;
-        readonly baseline_hash: Schema.optionalKey<Schema.String>;
-        readonly current_hash: Schema.optionalKey<Schema.String>;
-    }>>;
-}>;
-export interface ActivityManifestGuardResult extends Schema.Schema.Type<typeof ActivityManifestGuardResult> {
-}
-declare const ActivityManifestGuardFailed_base: Schema.Class<ActivityManifestGuardFailed, Schema.TaggedStruct<"ActivityManifestGuardFailed", {
-    readonly message: Schema.String;
-    readonly result: Schema.Struct<{
-        readonly status: Schema.Literals<readonly ["pass", "fail"]>;
-        readonly waiting_executions: Schema.Int;
-        readonly breaking_changes: Schema.$Array<Schema.Struct<{
-            readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
-            readonly name: Schema.String;
-            readonly baseline_hash: Schema.optionalKey<Schema.String>;
-            readonly current_hash: Schema.optionalKey<Schema.String>;
-        }>>;
-        readonly additive_changes: Schema.$Array<Schema.Struct<{
-            readonly type: Schema.Literals<readonly ["removed", "changed", "added"]>;
-            readonly name: Schema.String;
-            readonly baseline_hash: Schema.optionalKey<Schema.String>;
-            readonly current_hash: Schema.optionalKey<Schema.String>;
-        }>>;
-    }>;
-}>, import("effect/Cause").YieldableError>;
-export declare class ActivityManifestGuardFailed extends ActivityManifestGuardFailed_base {
-}
-export declare const currentManifest: () => Effect.Effect<{
-    version: 1;
-    generated_from: string;
-    hash_algorithm: "sha256-json-schema-v1";
-    activities: {
-        name: string;
-        signature_hash: string;
-    }[];
-}, import("effect/PlatformError").PlatformError, Crypto.Crypto>;
-export declare function diffManifests(baseline: ActivityManifest, current: ActivityManifest): {
-    breaking: Array<ActivityManifestChange>;
-    additive: Array<ActivityManifestChange>;
-};
-export declare function diffManifests(current: ActivityManifest): (baseline: ActivityManifest) => {
-    breaking: Array<ActivityManifestChange>;
-    additive: Array<ActivityManifestChange>;
-};
-export declare const evaluateGuard: (input: {
-    readonly baseline: ActivityManifest;
-    readonly current: ActivityManifest;
-    readonly waitingExecutions: number;
-}) => ActivityManifestGuardResult;
-export declare const guard: (input: {
-    readonly baseline: ActivityManifest;
-    readonly current: ActivityManifest;
-    readonly waitingExecutions: number;
-}) => Effect.Effect<ActivityManifestGuardResult, ActivityManifestGuardFailed, never>;
-export {};

package/dist/types/runtime/workflow/definition-runtime.d.ts

@@ -1,95 +0,0 @@
-import { ChildOrchestration, Ids, Shared, Workflow } from "../../schema/index";
-import { WorkflowDefinitionRepository } from "@relayfx/store-sql/portable";
-import { Cause, Context, Effect, Layer, Schema } from "effect";
-import { SqlError } from "effect/unstable/sql/SqlError";
-export interface SideEffectContext {
-    readonly execution_id: Ids.ExecutionId;
-    readonly operation_id: Ids.WorkflowOperationId;
-    readonly idempotency_key: string;
-}
-declare const UnsupportedOperation_base: Schema.Class<UnsupportedOperation, Schema.TaggedStruct<"UnsupportedWorkflowOperation", {
-    readonly operation_id: Schema.brand<Schema.String, "Relay.WorkflowOperationId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
-    };
-    readonly kind: Schema.String;
-}>, Cause.YieldableError>;
-export declare class UnsupportedOperation extends UnsupportedOperation_base {
-}
-declare const PinnedDefinitionNotFound_base: Schema.Class<PinnedDefinitionNotFound, Schema.TaggedStruct<"PinnedWorkflowDefinitionNotFound", {
-    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-}>, Cause.YieldableError>;
-export declare class PinnedDefinitionNotFound extends PinnedDefinitionNotFound_base {
-}
-declare const PinnedDefinitionMismatch_base: Schema.Class<PinnedDefinitionMismatch, Schema.TaggedStruct<"PinnedWorkflowDefinitionMismatch", {
-    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-}>, Cause.YieldableError>;
-export declare class PinnedDefinitionMismatch extends PinnedDefinitionMismatch_base {
-}
-declare const WorkflowRuntimeError_base: Schema.Class<WorkflowRuntimeError, Schema.TaggedStruct<"WorkflowRuntimeError", {
-    readonly message: Schema.String;
-}>, Cause.YieldableError>;
-export declare class WorkflowRuntimeError extends WorkflowRuntimeError_base {
-}
-declare const WorkflowJoinPolicyNotSatisfied_base: Schema.Class<WorkflowJoinPolicyNotSatisfied, Schema.TaggedStruct<"WorkflowJoinPolicyNotSatisfied", {
-    readonly policy: Schema.String;
-}>, Cause.YieldableError>;
-export declare class WorkflowJoinPolicyNotSatisfied extends WorkflowJoinPolicyNotSatisfied_base {
-}
-export interface Handlers {
-    readonly tool?: (executionId: Ids.ExecutionId, operation: typeof Workflow.ToolOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
-    readonly child: (executionId: Ids.ExecutionId, operation: typeof Workflow.ChildOperation.Type | typeof Workflow.DispatchableChildOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
-    readonly approval: (executionId: Ids.ExecutionId, operation: typeof Workflow.ApprovalOperation.Type, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
-    readonly timer: (executionId: Ids.ExecutionId, operation: typeof Workflow.TimerOperation.Type, context: SideEffectContext) => Effect.Effect<void, WorkflowRuntimeError>;
-    readonly branch: (executionId: Ids.ExecutionId, operation: typeof Workflow.BranchOperation.Type, context: SideEffectContext) => Effect.Effect<boolean, WorkflowRuntimeError>;
-    readonly structuredCompletion: (schemaRef: string, value: Shared.JsonValue | undefined, context: SideEffectContext) => Effect.Effect<Shared.JsonValue, WorkflowRuntimeError>;
-    readonly createChildFanOut?: (definition: ChildOrchestration.FanOutDefinition, context: SideEffectContext) => Effect.Effect<ChildOrchestration.FanOutState, WorkflowRuntimeError>;
-    readonly admitChildFanOut?: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<void, WorkflowRuntimeError>;
-    readonly inspectChildFanOut?: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<ChildOrchestration.FanOutState | undefined, WorkflowRuntimeError>;
-}
-declare const HandlerService_base: Context.ServiceClass<HandlerService, "@relayfx/runtime/workflow/definition-runtime/HandlerService", Handlers>;
-export declare class HandlerService extends HandlerService_base {
-}
-export interface Interface {
-    readonly start: (input: Workflow.StartRunPayload) => Effect.Effect<Workflow.RunRecord, WorkflowDefinitionRepository.RepositoryError | SqlError>;
-    readonly run: (executionId: Ids.ExecutionId) => Effect.Effect<Shared.JsonValue | undefined, WorkflowExecutionError>;
-    readonly recover: Effect.Effect<ReadonlyArray<Ids.ExecutionId>, WorkflowRuntimeError>;
-    readonly inspect: (executionId: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, WorkflowDefinitionRepository.RepositoryError | SqlError>;
-    readonly replay: (executionId: Ids.ExecutionId) => Effect.Effect<ReadonlyArray<Workflow.LifecycleEvent>, WorkflowDefinitionRepository.RepositoryError | SqlError>;
-    readonly cancel: (executionId: Ids.ExecutionId) => Effect.Effect<Workflow.RunRecord | undefined, WorkflowDefinitionRepository.RepositoryError | SqlError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/workflow/definition-runtime/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const fanOutIdFor: {
-    (fanOutKey: string): (executionId: Ids.ExecutionId) => Ids.ChildFanOutId;
-    (executionId: Ids.ExecutionId, fanOutKey: string): Ids.ChildFanOutId;
-};
-declare const WorkflowCancelled_base: Schema.Class<WorkflowCancelled, Schema.TaggedStruct<"WorkflowCancelled", {}>, Cause.YieldableError>;
-export declare class WorkflowCancelled extends WorkflowCancelled_base {
-}
-declare const WorkflowBudgetExceeded_base: Schema.Class<WorkflowBudgetExceeded, Schema.TaggedStruct<"WorkflowBudgetExceeded", {
-    readonly operation_id: Schema.brand<Schema.String, "Relay.WorkflowOperationId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.WorkflowOperationId">;
-    };
-}>, Cause.YieldableError>;
-export declare class WorkflowBudgetExceeded extends WorkflowBudgetExceeded_base {
-}
-declare const WorkflowJoining_base: Schema.Class<WorkflowJoining, Schema.TaggedStruct<"WorkflowJoining", {
-    readonly fan_out_id: Schema.brand<Schema.String, "Relay.ChildFanOutId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildFanOutId">;
-    };
-}>, Cause.YieldableError>;
-export declare class WorkflowJoining extends WorkflowJoining_base {
-}
-type WorkflowExecutionError = WorkflowDefinitionRepository.RepositoryError | SqlError | WorkflowRuntimeError | UnsupportedOperation | PinnedDefinitionNotFound | PinnedDefinitionMismatch | WorkflowCancelled | WorkflowBudgetExceeded | WorkflowJoining | WorkflowJoinPolicyNotSatisfied;
-export declare const validate: (definition: Workflow.Definition) => Effect.Effect<void, never, never> | Effect.Effect<never, UnsupportedOperation, never>;
-export declare const run: (executionId: string & import("effect/Brand").Brand<"Relay.ExecutionId">) => Effect.Effect<Schema.Json | undefined, PinnedDefinitionMismatch | PinnedDefinitionNotFound | WorkflowDefinitionRepository.RepositoryError | SqlError | UnsupportedOperation | WorkflowBudgetExceeded | WorkflowCancelled | WorkflowJoinPolicyNotSatisfied | WorkflowJoining | WorkflowRuntimeError, HandlerService | WorkflowDefinitionRepository.Service>;
-export declare const handlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
-export declare const testHandlersLayer: typeof handlersLayer;
-export declare const layerFromRuntime: Layer.Layer<Service, WorkflowRuntimeError, HandlerService | WorkflowDefinitionRepository.Service>;
-export declare const layer: Layer.Layer<Service, WorkflowRuntimeError, HandlerService | WorkflowDefinitionRepository.Service>;
-export {};