@relayfx/test 0.3.0 → 0.3.2

package/dist/types/runtime/child/child-fan-out-admission-service.d.ts

@@ -1,30 +0,0 @@
-import { ChildOrchestration, Execution, Ids } from "../../schema/index";
-import { ChildFanOutRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as ChildRunService, type AgentContext } from "./child-run-service";
-declare const ChildFanOutAdmissionError_base: Schema.Class<ChildFanOutAdmissionError, Schema.TaggedStruct<"ChildFanOutAdmissionError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ChildFanOutAdmissionError extends ChildFanOutAdmissionError_base {
-}
-export interface AdmitInput {
-    readonly fanOutId: Ids.ChildFanOutId;
-    readonly parent: AgentContext;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly admittedAt: number;
-}
-export interface Interface {
-    readonly admit: (input: AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
-    readonly recover: (input: AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
-    readonly recoverAll: (inputFor: (fanOut: ChildOrchestration.FanOutState) => AdmitInput) => Effect.Effect<ReadonlyArray<Execution.ChildRunAccepted>, ChildFanOutAdmissionError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-fan-out-admission-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, ChildFanOutRepository.Service | ChildRunService>;
-export declare const memoryLayer: Layer.Layer<Service, never, never>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const admit: (input: AdmitInput) => Effect.Effect<readonly Execution.ChildRunAccepted[], ChildFanOutAdmissionError, Service>;
-export declare const recover: (input: AdmitInput) => Effect.Effect<readonly Execution.ChildRunAccepted[], ChildFanOutAdmissionError, Service>;
-export declare const recoverAll: (inputFor: (fanOut: ChildOrchestration.FanOutState) => AdmitInput) => Effect.Effect<readonly Execution.ChildRunAccepted[], ChildFanOutAdmissionError, Service>;
-export {};

package/dist/types/runtime/child/child-fan-out-runtime.d.ts

@@ -1,40 +0,0 @@
-import { ChildOrchestration, Content, Ids } from "../../schema/index";
-import { ChildFanOutRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as TransitionService } from "./child-fan-out-transition-service";
-export interface ChildResult {
-    readonly status: "completed" | "failed" | "cancelled";
-    readonly output: ReadonlyArray<Content.Part>;
-    readonly error?: string;
-    readonly completedAt?: number;
-}
-export interface Handlers {
-    readonly execute: (child: ChildOrchestration.FanOutChild, fanOut: ChildOrchestration.FanOutState, idempotencyKey: string) => Effect.Effect<ChildResult, {
-        readonly _tag: string;
-    }>;
-    readonly cancel: (childExecutionId: Ids.ChildExecutionId, reason: string) => Effect.Effect<void, {
-        readonly _tag: string;
-    }>;
-}
-declare const HandlerService_base: Context.ServiceClass<HandlerService, "@relayfx/runtime/child/child-fan-out-runtime/HandlerService", Handlers>;
-export declare class HandlerService extends HandlerService_base {
-}
-declare const ChildFanOutRuntimeError_base: Schema.Class<ChildFanOutRuntimeError, Schema.TaggedStruct<"ChildFanOutRuntimeError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ChildFanOutRuntimeError extends ChildFanOutRuntimeError_base {
-}
-export interface Interface {
-    readonly create: (definition: ChildOrchestration.FanOutDefinition) => Effect.Effect<ChildOrchestration.FanOutState, ChildFanOutRuntimeError>;
-    readonly recover: (_?: never) => Effect.Effect<ReadonlyArray<Ids.ChildFanOutId>, ChildFanOutRuntimeError>;
-    readonly cancel: (fanOutId: Ids.ChildFanOutId, cancelledAt: number, reason: string) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRuntimeError>;
-    readonly inspect: (fanOutId: Ids.ChildFanOutId) => Effect.Effect<ChildOrchestration.FanOutState | undefined, ChildFanOutRuntimeError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-fan-out-runtime/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layerFromRuntime: Layer.Layer<Service, ChildFanOutRuntimeError, HandlerService | ChildFanOutRepository.Service | TransitionService>;
-export declare const layer: Layer.Layer<Service, ChildFanOutRuntimeError, HandlerService | ChildFanOutRepository.Service | TransitionService>;
-export declare const handlersLayer: (handlers: Handlers) => Layer.Layer<HandlerService, never, never>;
-export declare const testHandlersLayer: typeof handlersLayer;
-export {};

package/dist/types/runtime/child/child-fan-out-transition-service.d.ts

@@ -1,25 +0,0 @@
-import { Content, Ids } from "../../schema/index";
-import { ChildFanOutRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
-declare const ChildFanOutTransitionError_base: Schema.Class<ChildFanOutTransitionError, Schema.TaggedStruct<"ChildFanOutTransitionError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ChildFanOutTransitionError extends ChildFanOutTransitionError_base {
-}
-export interface TerminalInput {
-    readonly childExecutionId: Ids.ChildExecutionId;
-    readonly status: "completed" | "failed" | "cancelled";
-    readonly output: ReadonlyArray<Content.Part>;
-    readonly error?: string;
-    readonly completedAt: number;
-}
-export interface Interface {
-    readonly terminal: (input: TerminalInput) => Effect.Effect<ChildFanOutRepository.RecordTerminalResult | undefined, ChildFanOutTransitionError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-fan-out-transition-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const layer: Layer.Layer<Service, never, ChildFanOutRepository.Service | EventLogService>;
-export declare const terminal: (input: TerminalInput) => Effect.Effect<ChildFanOutRepository.RecordTerminalResult | undefined, ChildFanOutTransitionError, Service>;
-export {};

package/dist/types/runtime/child/child-run-service.d.ts

@@ -1,96 +0,0 @@
-import { Agent, Execution, Ids, Shared } from "../../schema/index";
-import { ChildExecutionRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
-declare const StaticChildRunPresetNotFound_base: Schema.Class<StaticChildRunPresetNotFound, Schema.TaggedStruct<"StaticChildRunPresetNotFound", {
-    readonly preset_name: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class StaticChildRunPresetNotFound extends StaticChildRunPresetNotFound_base {
-}
-declare const ChildRunScopeBroadened_base: Schema.Class<ChildRunScopeBroadened, Schema.TaggedStruct<"ChildRunScopeBroadened", {
-    readonly field: Schema.Literals<readonly ["tool_names", "permissions"]>;
-    readonly value: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ChildRunScopeBroadened extends ChildRunScopeBroadened_base {
-}
-declare const ChildRunServiceError_base: Schema.Class<ChildRunServiceError, Schema.TaggedStruct<"ChildRunServiceError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ChildRunServiceError extends ChildRunServiceError_base {
-}
-declare const ChildRunWorkspaceUnavailable_base: Schema.Class<ChildRunWorkspaceUnavailable, Schema.TaggedStruct<"ChildRunWorkspaceUnavailable", {
-    readonly reason: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ChildRunWorkspaceUnavailable extends ChildRunWorkspaceUnavailable_base {
-}
-declare const ChildRunModelMissing_base: Schema.Class<ChildRunModelMissing, Schema.TaggedStruct<"ChildRunModelMissing", {}>, import("effect/Cause").YieldableError>;
-export declare class ChildRunModelMissing extends ChildRunModelMissing_base {
-}
-export interface AgentContext {
-    readonly instructions?: string;
-    readonly model?: Agent.ModelSelection;
-    readonly compactionPolicy?: Agent.CompactionPolicy;
-    readonly toolNames: ReadonlyArray<string>;
-    readonly permissions: ReadonlyArray<string>;
-    readonly outputSchemaRef?: string;
-    readonly metadata?: Shared.Metadata;
-}
-export interface ChildRunOverride {
-    readonly instructions?: string;
-    readonly model?: Agent.ModelSelection;
-    readonly compactionPolicy?: Agent.CompactionPolicy;
-    readonly toolNames?: ReadonlyArray<string>;
-    readonly permissions?: ReadonlyArray<string>;
-    readonly workspacePolicy?: Agent.ChildRunWorkspacePolicy;
-    readonly outputSchemaRef?: string;
-    readonly metadata?: Shared.Metadata;
-}
-export interface ChildRunPreset extends ChildRunOverride {
-}
-export interface SpawnStaticInput {
-    readonly childExecutionId: Ids.ChildExecutionId;
-    readonly executionId: Ids.ExecutionId;
-    readonly addressId: Ids.AddressId;
-    readonly parent: AgentContext;
-    readonly presets: ReadonlyMap<string, ChildRunPreset>;
-    readonly presetName: string;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-}
-export interface SpawnDynamicInput {
-    readonly childExecutionId: Ids.ChildExecutionId;
-    readonly executionId: Ids.ExecutionId;
-    readonly addressId: Ids.AddressId;
-    readonly parent: AgentContext;
-    readonly override?: ChildRunOverride;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly createdAt: number;
-}
-export interface Interface {
-    readonly spawnStatic: (input: SpawnStaticInput) => Effect.Effect<Execution.ChildRunAccepted, StaticChildRunPresetNotFound | ChildRunScopeBroadened | ChildRunWorkspaceUnavailable | ChildRunServiceError>;
-    readonly spawnDynamic: (input: SpawnDynamicInput) => Effect.Effect<Execution.ChildRunAccepted, ChildRunScopeBroadened | ChildRunWorkspaceUnavailable | ChildRunServiceError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/child-run-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export interface ResolvedChildContext {
-    readonly instructions?: string;
-    readonly model?: Agent.ModelSelection;
-    readonly compactionPolicy?: Agent.CompactionPolicy;
-    readonly toolNames: ReadonlyArray<string>;
-    readonly permissions: ReadonlyArray<string>;
-    readonly workspacePolicy?: Agent.ChildRunWorkspacePolicy;
-    readonly outputSchemaRef?: string;
-    readonly metadata: Shared.Metadata;
-}
-export declare const layer: Layer.Layer<Service, never, ChildExecutionRepository.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 resolveForDispatch: (input: Execution.SpawnChildRunInput) => Effect.Effect<ResolvedChildContext, ChildRunScopeBroadened | StaticChildRunPresetNotFound, never>;
-export declare const childDefinition: {
-    (context: ResolvedChildContext): (parentDefinition: Agent.Definition) => Effect.Effect<Agent.Definition, ChildRunModelMissing>;
-    (parentDefinition: Agent.Definition, context: ResolvedChildContext): Effect.Effect<Agent.Definition, ChildRunModelMissing>;
-};
-export declare const spawnStatic: (input: SpawnStaticInput) => Effect.Effect<Execution.ChildRunAccepted, ChildRunScopeBroadened | ChildRunServiceError | ChildRunWorkspaceUnavailable | StaticChildRunPresetNotFound, Service>;
-export declare const spawnDynamic: (input: SpawnDynamicInput) => Effect.Effect<Execution.ChildRunAccepted, ChildRunScopeBroadened | ChildRunServiceError | ChildRunWorkspaceUnavailable, Service>;
-export {};

package/dist/types/runtime/child/parent-notifier-service.d.ts

@@ -1,42 +0,0 @@
-import { Content, Ids } from "../../schema/index";
-import { ChildExecutionRepository } from "@relayfx/store-sql/portable";
-import { Context, Effect, Layer, Ref, Schema } from "effect";
-import { Service as EventLogService } from "../execution/event-log-service";
-import { Service as WaitServiceService } from "../wait/wait-service";
-declare const ParentNotifyError_base: Schema.Class<ParentNotifyError, Schema.TaggedStruct<"ParentNotifyError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ParentNotifyError extends ParentNotifyError_base {
-}
-export declare const ChildTerminalStatus: Schema.Literals<readonly ["completed", "failed", "cancelled"]>;
-export type ChildTerminalStatus = typeof ChildTerminalStatus.Type;
-export interface NotifyInput {
-    readonly parentExecutionId: Ids.ExecutionId;
-    readonly childExecutionId: Ids.ChildExecutionId;
-    readonly parentWaitId?: Ids.WaitId;
-    readonly status: ChildTerminalStatus;
-    readonly output: ReadonlyArray<Content.Part>;
-    readonly notifiedAt: number;
-}
-export interface Interface {
-    readonly notify: (input: NotifyInput) => Effect.Effect<void, ParentNotifyError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/child/parent-notifier-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export interface SignalParentWaitInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly waitId: Ids.WaitId;
-    readonly signaledAt: number;
-}
-export interface MakeOptions {
-    readonly signalWait: (input: SignalParentWaitInput) => Effect.Effect<void, {
-        readonly _tag: string;
-    }>;
-}
-export declare const make: (options: MakeOptions) => Effect.Effect<Interface, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;
-export declare const layerWith: (options: MakeOptions) => Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLogService | WaitServiceService>;
-export declare const memoryLayer: (notifications?: Ref.Ref<ReadonlyArray<NotifyInput>>) => Layer.Layer<Service, never, never>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
-export declare const notify: (input: NotifyInput) => Effect.Effect<void, ParentNotifyError, Service>;
-export {};

package/dist/types/runtime/child/spawn-child-run-tool.d.ts

@@ -1,225 +0,0 @@
-import { Agent, Content, Execution, Ids, Shared } from "../../schema/index";
-import { Effect, Schema } from "effect";
-import { ToolRuntimeError } from "../tool/tool-runtime-service";
-import type { RegisteredTool } from "../tool/tool-runtime-service";
-import type { Interface as EventLogInterface } from "../execution/event-log-service";
-import type { Interface as WaitServiceInterface } from "../wait/wait-service";
-import type { Interface as ChildRunServiceInterface } from "./child-run-service";
-export declare const toolName = "spawn_child_run";
-export declare const permissionName = "relay.child_run.spawn";
-export declare const Input: Schema.Struct<{
-    readonly preset_name: Schema.optionalKey<Schema.String>;
-    readonly instructions: Schema.optionalKey<Schema.String>;
-    readonly model: Schema.optionalKey<Schema.Struct<{
-        readonly provider: Schema.String;
-        readonly model: Schema.String;
-        readonly registration_key: Schema.optionalKey<Schema.String>;
-        readonly request_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>>>;
-    }>>;
-    readonly compaction_policy: Schema.optionalKey<Schema.Struct<{
-        readonly context_window: Schema.Finite;
-        readonly reserve_tokens: Schema.Finite;
-        readonly keep_recent_tokens: Schema.Finite;
-        readonly summary_model: Schema.optionalKey<Schema.Struct<{
-            readonly provider: Schema.String;
-            readonly model: Schema.String;
-            readonly registration_key: Schema.optionalKey<Schema.String>;
-            readonly request_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>>>;
-        }>>;
-    }>>;
-    readonly tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    readonly output_schema_ref: Schema.optionalKey<Schema.String>;
-    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"structured">;
-        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        readonly schema_ref: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"blob-reference">;
-        readonly uri: Schema.String;
-        readonly media_type: Schema.String;
-        readonly filename: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"artifact-reference">;
-        readonly artifact_id: Schema.String;
-        readonly media_type: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"tool-call">;
-        readonly call: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly name: Schema.String;
-            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"tool-result">;
-        readonly result: Schema.Struct<{
-            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            readonly error: Schema.optionalKey<Schema.String>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        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 interface Input extends Schema.Schema.Type<typeof Input> {
-}
-export declare const Output: Schema.Struct<{
-    readonly child_execution_id: Schema.brand<Schema.String, "Relay.ChildExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ChildExecutionId">;
-    };
-    readonly status: Schema.Literals<readonly ["completed", "failed", "cancelled"]>;
-    readonly output: Schema.$Array<Schema.Union<readonly [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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"structured">;
-        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        readonly schema_ref: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"blob-reference">;
-        readonly uri: Schema.String;
-        readonly media_type: Schema.String;
-        readonly filename: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"artifact-reference">;
-        readonly artifact_id: Schema.String;
-        readonly media_type: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"tool-call">;
-        readonly call: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly name: Schema.String;
-            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"tool-result">;
-        readonly result: Schema.Struct<{
-            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            readonly error: Schema.optionalKey<Schema.String>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        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 interface Output extends Schema.Schema.Type<typeof Output> {
-}
-export declare const TransferInput: Schema.Struct<{
-    readonly input: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"structured">;
-        readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        readonly schema_ref: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"blob-reference">;
-        readonly uri: Schema.String;
-        readonly media_type: Schema.String;
-        readonly filename: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"artifact-reference">;
-        readonly artifact_id: Schema.String;
-        readonly media_type: Schema.optionalKey<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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"tool-call">;
-        readonly call: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly name: Schema.String;
-            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        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>>>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"tool-result">;
-        readonly result: Schema.Struct<{
-            readonly call_id: Schema.brand<Schema.String, "Relay.ToolCallId"> & {
-                make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ToolCallId">;
-            };
-            readonly output: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-            readonly error: Schema.optionalKey<Schema.String>;
-            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-        }>;
-        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 interface TransferInput extends Schema.Schema.Type<typeof TransferInput> {
-}
-export interface DispatchInput {
-    readonly executionId: Ids.ExecutionId;
-    readonly rootAddressId: Ids.AddressId;
-    readonly sessionId: Ids.SessionId;
-    readonly input: ReadonlyArray<Content.Part>;
-    readonly eventSequence: Execution.ExecutionEventSequence;
-    readonly startedAt: number;
-    readonly completedAt: number;
-    readonly agentId: Ids.AgentId;
-    readonly agentRevision: Agent.DefinitionRevision;
-    readonly agentSnapshot: Agent.Definition;
-    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
-    readonly metadata: Shared.Metadata;
-}
-export interface Config {
-    readonly agent: Agent.Definition;
-    readonly agentId: Ids.AgentId;
-    readonly agentRevision: Agent.DefinitionRevision;
-    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
-    readonly childRuns: ChildRunServiceInterface;
-    readonly eventLog: EventLogInterface;
-    readonly waits: WaitServiceInterface;
-    readonly dispatch: (input: DispatchInput) => Effect.Effect<void, ToolRuntimeError>;
-}
-export declare const enabled: (agent: Agent.Definition) => boolean;
-export declare const registeredTool: (config: Config) => RegisteredTool;
-export declare const transferToolName: (name: string) => string;
-export declare const transferTools: (config: Config) => ReadonlyArray<RegisteredTool>;

package/dist/types/runtime/cluster/execution-entity.d.ts

@@ -1,39 +0,0 @@
-import type { ChildExecutionRepository, EnvelopeRepository, ExecutionRepository, ToolCallRepository } from "@relayfx/store-sql/portable";
-import { Entity } from "effect/unstable/cluster";
-import { Rpc } from "effect/unstable/rpc";
-import type { WorkflowEngine } from "effect/unstable/workflow";
-import { Schema } from "effect";
-import type { Effect } from "effect";
-import { ExecutionWorkflowFailed, StartInput, StartResult } from "../workflow/execution-workflow";
-import type { Service as ActiveExecutionRegistryService } from "../execution/active-execution-registry";
-import type { Service as EventLogService } from "../execution/event-log-service";
-import type { Service as ExecutionServiceService } from "../execution/execution-service";
-import type { Service as ToolTransitionCoordinatorService } from "../tool/tool-transition-coordinator";
-import type { Service as WaitServiceService } from "../wait/wait-service";
-export declare const Start: Rpc.Rpc<"start", typeof StartInput, typeof StartResult, typeof ExecutionWorkflowFailed>;
-export declare const SignalWait: Rpc.Rpc<"signalWait", Schema.Struct<{
-    readonly workflow_execution_id: 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">;
-    };
-    readonly state: Schema.Literals<readonly ["resolved", "timed_out", "cancelled"]>;
-    readonly signaled_at: Schema.Int;
-}>, Schema.Void, typeof ExecutionWorkflowFailed, never, never>;
-export declare const Dispatch: Rpc.Rpc<"dispatch", typeof StartInput, typeof Schema.Void, typeof ExecutionWorkflowFailed>;
-export declare const Cancel: Rpc.Rpc<"cancel", Schema.Struct<{
-    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-    readonly cancelled_at: Schema.Int;
-    readonly reason: Schema.optionalKey<Schema.String>;
-}>, Schema.Struct<{
-    readonly execution_id: Schema.brand<Schema.String, "Relay.ExecutionId"> & {
-        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.ExecutionId">;
-    };
-    readonly status: Schema.Literals<readonly ["queued", "running", "waiting", "completed", "failed", "cancelled"]>;
-}>, typeof ExecutionWorkflowFailed, never, never>;
-type ExecutionRpc = typeof Start | typeof Dispatch | typeof SignalWait | typeof Cancel;
-export declare const entity: Entity.Entity<"Relay/Execution", ExecutionRpc>;
-export declare const layer: import("effect/Layer").Layer<never, never, ChildExecutionRepository.Service | EnvelopeRepository.Service | ExecutionRepository.Service | ToolCallRepository.Service | EventLogService | WaitServiceService | ExecutionServiceService | ActiveExecutionRegistryService | ToolTransitionCoordinatorService | import("effect/unstable/cluster/Sharding").Sharding | WorkflowEngine.WorkflowEngine>;
-export declare const client: Effect.Effect<(entityId: string) => import("effect/unstable/rpc/RpcClient").RpcClient.From<ExecutionRpc, import("effect/unstable/cluster/ClusterError").AlreadyProcessingMessage | import("effect/unstable/cluster/ClusterError").MailboxFull | import("effect/unstable/cluster/ClusterError").PersistenceError>, never, import("effect/unstable/cluster/Sharding").Sharding>;
-export {};

package/dist/types/runtime/content/artifact-store-service.d.ts

@@ -1,26 +0,0 @@
-import { Content } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
-declare const ArtifactNotResolvable_base: Schema.Class<ArtifactNotResolvable, Schema.TaggedStruct<"ArtifactNotResolvable", {
-    readonly artifact_id: Schema.String;
-    readonly reason: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class ArtifactNotResolvable extends ArtifactNotResolvable_base {
-}
-export interface Interface {
-    readonly resolve: (part: Content.ArtifactReferencePart) => Effect.Effect<ReadonlyArray<Content.Part>, ArtifactNotResolvable>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/content/artifact-store-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const passthroughLayer: Layer.Layer<Service>;
-export interface MemoryInterface extends Interface {
-    readonly register: (artifact_id: string, parts: ReadonlyArray<Content.Part>) => Effect.Effect<void>;
-}
-declare const Memory_base: Context.ServiceClass<Memory, "@relayfx/runtime/content/artifact-store-service/Memory", MemoryInterface>;
-export declare class Memory extends Memory_base {
-}
-export declare const memoryLayer: Layer.Layer<Service | Memory>;
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
-export declare const resolve: (part: Content.ArtifactReferencePart) => Effect.Effect<readonly Content.Part[], ArtifactNotResolvable, Service>;
-export declare const register: (artifact_id: string, parts: readonly Content.Part[]) => Effect.Effect<void, never, Memory>;
-export {};

package/dist/types/runtime/content/blob-store-service.d.ts

@@ -1,54 +0,0 @@
-import { Content, Shared } from "../../schema/index";
-import { Context, Effect, Layer, Schema } from "effect";
-declare const BlobNotResolvable_base: Schema.Class<BlobNotResolvable, Schema.TaggedStruct<"BlobNotResolvable", {
-    readonly uri: Schema.String;
-    readonly reason: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class BlobNotResolvable extends BlobNotResolvable_base {
-}
-declare const BlobStoreError_base: Schema.Class<BlobStoreError, Schema.TaggedStruct<"BlobStoreError", {
-    readonly message: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-export declare class BlobStoreError extends BlobStoreError_base {
-}
-export type ResolvedBlob = {
-    readonly _tag: "Bytes";
-    readonly bytes: Uint8Array;
-    readonly mediaType: string;
-    readonly fileName?: string;
-} | {
-    readonly _tag: "Url";
-    readonly url: string;
-    readonly mediaType: string;
-    readonly fileName?: string;
-};
-export interface PutBlobInput {
-    readonly bytes: Uint8Array;
-    readonly mediaType: string;
-    readonly fileName?: string;
-    readonly metadata?: Shared.Metadata;
-}
-export interface Interface {
-    readonly resolve: (part: Content.BlobReferencePart) => Effect.Effect<ResolvedBlob, BlobNotResolvable | BlobStoreError>;
-    readonly put: (input: PutBlobInput) => Effect.Effect<Content.BlobReferencePart, BlobStoreError>;
-}
-declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/content/blob-store-service/Service", Interface>;
-export declare class Service extends Service_base {
-}
-export declare const passthroughLayer: Layer.Layer<Service>;
-export declare const memoryLayer: Layer.Layer<Service>;
-/**
- * Wraps a custom store implementation as a layer.
- *
- * @experimental
- */
-export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
-/**
- * @experimental
- */
-export declare const resolve: (part: Content.BlobReferencePart) => Effect.Effect<ResolvedBlob, BlobNotResolvable | BlobStoreError, Service>;
-/**
- * @experimental
- */
-export declare const put: (input: PutBlobInput) => Effect.Effect<Content.BlobReferencePart, BlobStoreError, Service>;
-export {};