@relayfx/test 0.1.0

package/dist/types/runtime/address/address-book-service.d.ts

@@ -0,0 +1,74 @@
+import { Address, Ids } from "../../schema/index";
+import { AddressBookRepository } from "@relayfx/store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+export declare const RouteKind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+export type RouteKind = typeof RouteKind.Type;
+export declare const Route: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+    readonly route_key: Schema.String;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface Route extends Address.Route {
+}
+export declare const RouteRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Relay.AddressBookEntryId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressBookEntryId">;
+    };
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly route: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+        readonly route_key: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly created_at: Schema.Int;
+    readonly updated_at: Schema.Int;
+}>;
+export interface RouteRecord extends Address.RouteRecord {
+}
+declare const AddressNotFound_base: Schema.Class<AddressNotFound, Schema.TaggedStruct<"AddressNotFound", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressNotFound extends AddressNotFound_base {
+}
+declare const AddressUnavailable_base: Schema.Class<AddressUnavailable, Schema.TaggedStruct<"AddressUnavailable", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly route_key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressUnavailable extends AddressUnavailable_base {
+}
+declare const AddressDeferred_base: Schema.Class<AddressDeferred, Schema.TaggedStruct<"AddressDeferred", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly route_key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressDeferred extends AddressDeferred_base {
+}
+declare const AddressBookServiceError_base: Schema.Class<AddressBookServiceError, Schema.TaggedStruct<"AddressBookServiceError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressBookServiceError extends AddressBookServiceError_base {
+}
+export interface Interface {
+    readonly resolve: (addressId: Ids.AddressId) => Effect.Effect<Route, AddressNotFound | AddressUnavailable | AddressDeferred | AddressBookServiceError>;
+    readonly register: (addressId: Ids.AddressId, route: Route) => Effect.Effect<Address.RouteRegistered, AddressBookServiceError>;
+    readonly get: (addressId: Ids.AddressId) => Effect.Effect<RouteRecord | undefined, AddressBookServiceError>;
+    readonly list: () => Effect.Effect<Address.RouteList, AddressBookServiceError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AddressBook", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layerFromRepository: Layer.Layer<Service, never, AddressBookRepository.Service>;
+export declare const memoryLayer: (entries?: Iterable<readonly [Ids.AddressId, Route]>) => Layer.Layer<Service, never, never>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const resolve: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<Route, AddressNotFound | AddressUnavailable | AddressDeferred | AddressBookServiceError, Service>;
+export declare const register: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">, route: Route) => Effect.Effect<Address.RouteRegistered, AddressBookServiceError, Service>;
+export declare const get: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<RouteRecord | undefined, AddressBookServiceError, Service>;
+export declare const list: () => Effect.Effect<Address.RouteList, AddressBookServiceError, Service>;
+export {};

package/dist/types/runtime/address/address-resolution-service.d.ts

@@ -0,0 +1,140 @@
+import { Agent, Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Service as AddressBookService } from "./address-book-service";
+import { Service as AgentRegistryService } from "../agent/agent-registry-service";
+declare const AddressRouteNotFound_base: Schema.Class<AddressRouteNotFound, Schema.TaggedStruct<"AddressRouteNotFound", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressRouteNotFound extends AddressRouteNotFound_base {
+}
+declare const AddressRouteKindMismatch_base: Schema.Class<AddressRouteKindMismatch, Schema.TaggedStruct<"AddressRouteKindMismatch", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly expected: Schema.Literal<"local-agent">;
+    readonly actual: Schema.Literals<readonly ["local-agent", "local-execution", "remote-relay", "local-adapter", "unavailable", "deferred-retry"]>;
+    readonly route_key: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressRouteKindMismatch extends AddressRouteKindMismatch_base {
+}
+declare const AddressAgentDefinitionNotFound_base: Schema.Class<AddressAgentDefinitionNotFound, Schema.TaggedStruct<"AddressAgentDefinitionNotFound", {
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressAgentDefinitionNotFound extends AddressAgentDefinitionNotFound_base {
+}
+declare const AddressResolutionError_base: Schema.Class<AddressResolutionError, Schema.TaggedStruct<"AddressResolutionError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AddressResolutionError extends AddressResolutionError_base {
+}
+export declare const LocalAgentRoute: Schema.Struct<{
+    readonly kind: Schema.Literal<"local-agent">;
+    readonly route_key: Schema.String;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+export interface LocalAgentRoute extends Schema.Schema.Type<typeof LocalAgentRoute> {
+}
+export declare const LocalAgentTarget: Schema.Struct<{
+    readonly address_id: Schema.brand<Schema.String, "Relay.AddressId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AddressId">;
+    };
+    readonly route: Schema.Struct<{
+        readonly kind: Schema.Literal<"local-agent">;
+        readonly route_key: Schema.String;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+    readonly agent_id: Schema.brand<Schema.String, "Relay.AgentId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentId">;
+    };
+    readonly agent_revision: Schema.Int;
+    readonly agent_snapshot: Schema.Codec<Agent.Definition, {
+        readonly name: string;
+        readonly permissions: readonly {
+            readonly name: string;
+            readonly value: Schema.Json;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+        }[];
+        readonly model: {
+            readonly provider: string;
+            readonly model: string;
+            readonly metadata?: {
+                readonly [x: string]: Schema.Json;
+            };
+            readonly registration_key?: string;
+            readonly request_options?: {
+                readonly [x: string]: Schema.Json;
+            };
+        };
+        readonly tool_names: readonly string[];
+        readonly metadata?: {
+            readonly [x: string]: Schema.Json;
+        };
+        readonly instructions?: string;
+        readonly output_schema_ref?: string;
+        readonly skill_definition_ids?: readonly string[];
+        readonly permission_rules?: {
+            readonly rules: readonly {
+                readonly pattern: string;
+                readonly level: "allow" | "deny" | "ask";
+                readonly reason?: string;
+            }[];
+            readonly fallback?: "allow" | "deny" | "ask";
+        };
+        readonly turn_policy?: Agent.TurnPolicySnapshot;
+        readonly max_tool_turns?: number;
+        readonly max_wait_turns?: number;
+        readonly token_budget?: number;
+        readonly child_run_presets?: {
+            readonly [x: string]: {
+                readonly metadata?: {
+                    readonly [x: string]: Schema.Json;
+                };
+                readonly permissions?: readonly string[];
+                readonly model?: {
+                    readonly provider: string;
+                    readonly model: string;
+                    readonly metadata?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                    readonly registration_key?: string;
+                    readonly request_options?: {
+                        readonly [x: string]: Schema.Json;
+                    };
+                };
+                readonly instructions?: string;
+                readonly tool_names?: readonly string[];
+                readonly workspace_policy?: {
+                    readonly mode: "share" | "fork";
+                    readonly fallback?: "fail" | "fresh";
+                };
+                readonly output_schema_ref?: string;
+            };
+        };
+        readonly handoff_targets?: readonly Schema.Struct.ReadonlySide<{
+            readonly name: Schema.String;
+            readonly preset_name: Schema.String;
+        }, "Encoded">[];
+    }, never, never>;
+    readonly tool_input_schema_digests: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export interface LocalAgentTarget extends Schema.Schema.Type<typeof LocalAgentTarget> {
+}
+export interface Interface {
+    readonly resolveLocalAgent: (addressId: Ids.AddressId) => Effect.Effect<LocalAgentTarget, AddressRouteNotFound | AddressRouteKindMismatch | AddressAgentDefinitionNotFound | AddressResolutionError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AddressResolution", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, AddressBookService | AgentRegistryService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const resolveLocalAgent: (addressId: string & import("effect/Brand").Brand<"Relay.AddressId">) => Effect.Effect<LocalAgentTarget, AddressRouteNotFound | AddressRouteKindMismatch | AddressAgentDefinitionNotFound | AddressResolutionError, Service>;
+export {};

package/dist/types/runtime/agent/agent-loop-service.d.ts

@@ -0,0 +1,85 @@
+import { Agent, Content, Execution, Ids, Shared, Tool } from "../../schema/index";
+import { AgentChatRepository } from "@relayfx/store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Tool as AiTool } from "effect/unstable/ai";
+import type { DispatchInput } from "../child/spawn-child-run-tool";
+import { Service as EventLogService } from "../execution/event-log-service";
+import { Service as LanguageModelServiceService } from "../model/language-model-service";
+import { Service as ModelCallPolicyService } from "../model/model-call-policy";
+import { Service as SchemaRegistryService } from "../schema-registry/schema-registry-service";
+import { Service as ToolRuntimeService } from "../tool/tool-runtime-service";
+import { Service as PromptAssemblerService } from "./prompt-assembler-service";
+import type { Options } from "./relay-compaction";
+declare const AgentLoopError_base: Schema.Class<AgentLoopError, Schema.TaggedStruct<"AgentLoopError", {
+    readonly message: Schema.String;
+    readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentLoopError extends AgentLoopError_base {
+}
+declare const AgentLoopWaitRequested_base: Schema.Class<AgentLoopWaitRequested, Schema.TaggedStruct<"AgentLoopWaitRequested", {
+    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 tool_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 next_event_sequence: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentLoopWaitRequested extends AgentLoopWaitRequested_base {
+}
+declare const AgentLoopBudgetExceeded_base: Schema.Class<AgentLoopBudgetExceeded, Schema.TaggedStruct<"AgentLoopBudgetExceeded", {
+    readonly tokens_used: Schema.Int;
+    readonly token_budget: Schema.Int;
+    readonly next_event_sequence: Schema.Int;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentLoopBudgetExceeded extends AgentLoopBudgetExceeded_base {
+}
+export interface RunInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly sessionId?: Ids.SessionId;
+    readonly agent: Agent.Definition;
+    readonly agentId?: Ids.AgentId;
+    readonly agentRevision?: Agent.DefinitionRevision;
+    readonly agentToolInputSchemaDigests?: Agent.ToolInputSchemaDigests;
+    readonly input: ReadonlyArray<Content.Part>;
+    readonly resumeToolCall?: Tool.Call;
+    readonly memorySubjectId?: Ids.MemorySubjectId;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly steeringEnabled?: boolean;
+    readonly toolOutputMaxBytes?: number | null;
+    readonly compaction?: Options | null;
+    readonly sessionEntryScope?: string;
+    readonly dispatchChildRun?: (input: DispatchInput) => Effect.Effect<void, unknown, any>;
+}
+export interface RunResult {
+    readonly metadata: Shared.Metadata;
+    readonly nextEventSequence: Execution.ExecutionEventSequence;
+}
+export interface Interface {
+    readonly run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AgentLoop", Interface>;
+export declare class Service extends Service_base {
+}
+/**
+ * Prompt for the terminal structured turn. The transcript already holds the full
+ * conversation history (system message, user input, and every tool result), so
+ * this single instruction is enough to elicit the typed final output.
+ *
+ * @experimental
+ */
+export declare const STRUCTURED_TURN_PROMPT = "Return the final structured output for the task above.";
+export declare const toolFromDefinition: (definition: Tool.Definition) => AiTool.Any;
+/** Map a Baton run failure (or an upstream model error) to the public error types. */
+export declare const mapBoundaryError: (error: unknown, current: Execution.ExecutionEventSequence) => AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded;
+export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLogService | ToolRuntimeService | LanguageModelServiceService | ModelCallPolicyService | SchemaRegistryService | PromptAssemblerService>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopBudgetExceeded | AgentLoopWaitRequested, Service>;
+export {};

package/dist/types/runtime/agent/agent-registry-service.d.ts

@@ -0,0 +1,31 @@
+import { Agent, Ids } from "../../schema/index";
+import { AgentDefinitionRepository } from "@relayfx/store-sql/portable";
+import { Context, Effect, Layer, Schema } from "effect";
+declare const AgentDefinitionInvalid_base: Schema.Class<AgentDefinitionInvalid, Schema.TaggedStruct<"AgentDefinitionInvalid", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentDefinitionInvalid extends AgentDefinitionInvalid_base {
+}
+declare const AgentRegistryError_base: Schema.Class<AgentRegistryError, Schema.TaggedStruct<"AgentRegistryError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class AgentRegistryError extends AgentRegistryError_base {
+}
+export interface Interface {
+    readonly register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError>;
+    readonly get: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError>;
+    readonly getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError>;
+    readonly list: () => Effect.Effect<Agent.DefinitionList, AgentRegistryError>;
+    readonly listRevisions: (id: Ids.AgentId) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AgentRegistry", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, AgentDefinitionRepository.Service>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const register: (input: Agent.RegisterDefinitionPayload) => Effect.Effect<Agent.DefinitionRegistered, AgentDefinitionInvalid | AgentRegistryError, Service>;
+export declare const get: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRecord | undefined, AgentRegistryError, Service>;
+export declare const getRevision: (input: AgentDefinitionRepository.GetAgentDefinitionRevisionInput) => Effect.Effect<Agent.DefinitionRevisionRecord | undefined, AgentRegistryError, Service>;
+export declare const list: () => Effect.Effect<Agent.DefinitionList, AgentRegistryError, Service>;
+export declare const listRevisions: (id: string & import("effect/Brand").Brand<"Relay.AgentId">) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError, Service>;
+export {};

package/dist/types/runtime/agent/prompt-assembler-service.d.ts

@@ -0,0 +1,64 @@
+import { Agent, Content, Shared, Tool } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Prompt } from "effect/unstable/ai";
+import { Service as ArtifactStoreService } from "../content/artifact-store-service";
+import { Service as BlobStoreService } from "../content/blob-store-service";
+declare const PromptAssemblerError_base: Schema.Class<PromptAssemblerError, Schema.TaggedStruct<"PromptAssemblerError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class PromptAssemblerError extends PromptAssemblerError_base {
+}
+export interface AssembleInput {
+    readonly agent: Agent.Definition;
+    readonly tools: ReadonlyArray<Tool.Definition>;
+    readonly input: ReadonlyArray<Content.Part>;
+    readonly tokenBudget?: number;
+    readonly metadata?: Shared.Metadata;
+}
+export interface Assembled {
+    readonly system: string;
+    readonly prompt: Prompt.Prompt;
+}
+export interface Interface {
+    readonly assemble: (input: AssembleInput) => Effect.Effect<Assembled, PromptAssemblerError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/PromptAssembler", Interface>;
+export declare class Service extends Service_base {
+}
+export type PureContentPart = Content.TextPart | Content.StructuredPart | Content.ToolCallPart | Content.ToolResultPart;
+export declare const contentToPromptPart: (part: PureContentPart) => Prompt.UserMessagePart;
+/**
+ * Default assembler that resolves reference content parts through the
+ * {@link BlobStore} and {@link ArtifactStore} it reads from context. Requires
+ * both stores to be provided (`runner-runtime-service.ts` wires passthrough
+ * stores by default; see `docs/spec/29-blob-and-artifact-stores.md`).
+ *
+ * @experimental
+ */
+export declare const defaultLayerWithStores: Layer.Layer<Service, never, BlobStoreService | ArtifactStoreService>;
+/**
+ * Default assembler: reproduces the agent loop's historical prompt construction,
+ * minus the model-selection dump (see `docs/spec/28-prompt-assembly.md`).
+ * Bakes in passthrough stores so it stays self-contained and behavior is
+ * preserved bit-for-bit (see `docs/spec/29-blob-and-artifact-stores.md`).
+ *
+ * @experimental
+ */
+export declare const defaultLayer: Layer.Layer<Service>;
+/**
+ * Wraps a custom assembler implementation as a layer.
+ *
+ * @experimental
+ */
+export declare const layer: (implementation: Interface) => Layer.Layer<Service>;
+/**
+ * Alias of {@link layer} for test wiring.
+ *
+ * @experimental
+ */
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service>;
+/**
+ * @experimental
+ */
+export declare const assemble: (input: AssembleInput) => Effect.Effect<Assembled, PromptAssemblerError, Service>;
+export {};

package/dist/types/runtime/agent/relay-approvals.d.ts

@@ -0,0 +1,2 @@
+import { Approvals } from "@batonfx/core";
+export declare const layer: import("effect/Layer").Layer<Approvals.Approvals, never, never>;

package/dist/types/runtime/agent/relay-compaction.d.ts

@@ -0,0 +1,23 @@
+import { Compaction } from "@batonfx/core";
+import { Ids } from "../../schema/index";
+import { CompactionRepository } from "@relayfx/store-sql/portable";
+import { Layer } from "effect";
+export interface Options {
+    readonly contextWindow?: number;
+    readonly reserveTokens?: number;
+    readonly keepRecentTokens?: number;
+}
+export interface Config {
+    readonly executionId: Ids.ExecutionId;
+    readonly repository: CompactionRepository.Interface;
+    readonly options?: Options;
+    readonly strategy?: Compaction.Strategy;
+}
+export declare const checkpointId: (input: {
+    readonly executionId: Ids.ExecutionId;
+    readonly turn: number;
+    readonly firstKeptEntryId: Ids.SessionEntryId | string;
+}) => string;
+export declare const strategy: (config: Config) => Compaction.Strategy;
+export declare const make: (config: Config) => Compaction.Interface;
+export declare const layer: (config: Config) => Layer.Layer<Compaction.Compaction>;

package/dist/types/runtime/agent/relay-instructions.d.ts

@@ -0,0 +1,7 @@
+import { Instructions } from "@batonfx/core";
+export interface ContextEpoch {
+    readonly baseline: string;
+    readonly dynamicSourceIds: ReadonlyArray<string>;
+}
+export declare const layerFromEpoch: (epoch: ContextEpoch) => import("effect/Layer").Layer<Instructions.Instructions, never, never>;
+export declare const layer: (system: string) => import("effect/Layer").Layer<Instructions.Instructions, never, never>;

package/dist/types/runtime/agent/relay-permissions.d.ts

@@ -0,0 +1,25 @@
+import { Permissions } from "@batonfx/core";
+import { Agent, Execution, Ids } from "../../schema/index";
+import { PermissionRuleRepository } from "@relayfx/store-sql/portable";
+import { Effect, Layer } from "effect";
+import type { Interface as EventLogInterface } from "../execution/event-log-service";
+import type { Interface as WaitServiceInterface } from "../wait/wait-service";
+export interface SequenceAllocator {
+    readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
+    readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
+    readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
+}
+export interface Config {
+    readonly ruleset: Agent.PermissionRuleset;
+    readonly repository: PermissionRuleRepository.Interface;
+    readonly waits: WaitServiceInterface;
+    readonly eventLog: EventLogInterface;
+    readonly allocator: SequenceAllocator;
+    readonly executionId: Ids.ExecutionId;
+    readonly agentName: string;
+    readonly scope: string;
+    readonly startedAt: number;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+}
+export declare const waitIdForToolCall: (toolCallId: string) => string & import("effect/Brand").Brand<"Relay.WaitId">;
+export declare const layer: (config: Config) => Layer.Layer<Permissions.Permissions | Permissions.RuleStore, never, never>;

package/dist/types/runtime/agent/relay-steering.d.ts

@@ -0,0 +1,17 @@
+import { Steering } from "@batonfx/core";
+import { Execution, Ids } from "../../schema/index";
+import { SteeringRepository } from "@relayfx/store-sql/portable";
+import { Effect, Layer } from "effect";
+import type { Interface } from "../execution/event-log-service";
+export interface SequenceAllocator {
+    readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
+}
+export interface Config {
+    readonly repository: SteeringRepository.Interface;
+    readonly eventLog: Interface;
+    readonly allocator: SequenceAllocator;
+    readonly executionId: Ids.ExecutionId;
+    readonly startedAt: number;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+}
+export declare const layer: (config: Config) => Layer.Layer<Steering.Steering>;

package/dist/types/runtime/agent/relay-tool-executor.d.ts

@@ -0,0 +1,22 @@
+import { ToolExecutor } from "@batonfx/core";
+import { Execution, Ids, Tool } from "../../schema/index";
+import { Effect, Layer } from "effect";
+import type { Interface as ToolRuntimeInterface, RegisteredTool } from "../tool/tool-runtime-service";
+import type { Interface as EventLogInterface } from "../execution/event-log-service";
+export interface Config {
+    readonly toolRuntime: ToolRuntimeInterface;
+    readonly eventLog: EventLogInterface;
+    readonly allocator: {
+        readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
+        readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
+    };
+    readonly executionId: Ids.ExecutionId;
+    readonly permissions: ReadonlyArray<Tool.Permission>;
+    readonly startedAt: number;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly toolOutputMaxBytes?: number;
+    readonly resumedToolCallId?: Ids.ToolCallId;
+    readonly extraTools?: ReadonlyArray<RegisteredTool>;
+}
+export declare const make: (config: Config) => ToolExecutor.Interface;
+export declare const layer: (config: Config) => Layer.Layer<ToolExecutor.ToolExecutor>;

package/dist/types/runtime/agent/relay-tool-output.d.ts

@@ -0,0 +1,7 @@
+import { ToolOutput } from "@batonfx/core";
+import { Effect, Layer, Option } from "effect";
+import type { Interface as BlobStoreInterface, Service as BlobStoreService } from "../content/blob-store-service";
+export declare const store: (blobStore: BlobStoreInterface, toolCallId: string, content: unknown) => Effect.Effect<Option.Option<string>, ToolOutput.ToolOutputError>;
+export declare const make: (blobStore: BlobStoreInterface) => ToolOutput.StoreInterface;
+export declare const layerFromBlobStore: (blobStore: BlobStoreInterface) => Layer.Layer<ToolOutput.ToolOutputStore>;
+export declare const layer: Layer.Layer<ToolOutput.ToolOutputStore, never, BlobStoreService>;

package/dist/types/runtime/agent/sequence-allocator.d.ts

@@ -0,0 +1,8 @@
+import { Execution } from "../../schema/index";
+import { Effect } from "effect";
+export interface SequenceAllocator {
+    readonly allocate: (count: number) => Effect.Effect<Execution.ExecutionEventSequence>;
+    readonly current: Effect.Effect<Execution.ExecutionEventSequence>;
+    readonly resetTo: (sequence: Execution.ExecutionEventSequence) => Effect.Effect<void>;
+}
+export declare const make: (first: Execution.ExecutionEventSequence) => Effect.Effect<SequenceAllocator>;

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

@@ -0,0 +1,90 @@
+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 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 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/ChildRunService", Interface>;
+export declare class Service extends Service_base {
+}
+export interface ResolvedChildContext {
+    readonly instructions?: string;
+    readonly model?: Agent.ModelSelection;
+    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, StaticChildRunPresetNotFound | ChildRunScopeBroadened, never>;
+export declare const childDefinition: (parentDefinition: Agent.Definition, context: ResolvedChildContext) => Effect.Effect<Agent.Definition, ChildRunModelMissing>;
+export declare const spawnStatic: (input: SpawnStaticInput) => Effect.Effect<Execution.ChildRunAccepted, StaticChildRunPresetNotFound | ChildRunScopeBroadened | ChildRunServiceError | ChildRunWorkspaceUnavailable, Service>;
+export declare const spawnDynamic: (input: SpawnDynamicInput) => Effect.Effect<Execution.ChildRunAccepted, ChildRunScopeBroadened | ChildRunServiceError | ChildRunWorkspaceUnavailable, Service>;
+export {};