@relayfx/sdk 0.0.1

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

@@ -0,0 +1,74 @@
+import { Address, Ids } from "../../schema/index";
+import { AddressBookRepository } from "../../store-sql/index";
+import { Context, Effect, Layer, Schema } from "effect";
+export declare const RouteKind: Schema.Literals<readonly ["local-agent", "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", "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", "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,106 @@
+import { Ids } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as AddressBook from "./address-book-service";
+import * as AgentRegistry 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", "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_definition_id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    };
+}>, 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_definition_id: Schema.brand<Schema.String, "Relay.AgentDefinitionId"> & {
+        make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.AgentDefinitionId">;
+    };
+    readonly agent_definition_revision: Schema.Int;
+    readonly agent_definition_snapshot: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly instructions: Schema.optionalKey<Schema.String>;
+        readonly model: 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.$Array<Schema.String>;
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly value: 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 child_run_presets: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+            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 tool_names: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly permissions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly workspace_policy: Schema.optionalKey<Schema.Struct<{
+                readonly mode: Schema.Literals<readonly ["share", "fork"]>;
+                readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["fail", "fresh"]>>;
+            }>>;
+            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 output_schema_ref: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>;
+}>;
+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, AddressBook.Service | AgentRegistry.Service>;
+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,53 @@
+import { Agent, Content, Execution, Ids, Shared, Tool } from "../../schema/index";
+import { AgentChatRepository } from "../../store-sql/index";
+import { Cause, Context, Effect, Layer, Schema } from "effect";
+import * as EventLog from "../execution/event-log-service";
+import * as LanguageModelService from "../model/language-model-service";
+import * as ModelCallPolicy from "../model/model-call-policy";
+import * as PromptAssembler from "./prompt-assembler-service";
+import * as ToolRuntime from "../tool/tool-runtime-service";
+declare const AgentLoopError_base: Schema.Class<AgentLoopError, Schema.TaggedStruct<"AgentLoopError", {
+    readonly message: Schema.String;
+    readonly next_event_sequence: Schema.optionalKey<Schema.Int>;
+}>, 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;
+}>, Cause.YieldableError>;
+export declare class AgentLoopWaitRequested extends AgentLoopWaitRequested_base {
+}
+export interface RunInput {
+    readonly executionId: Ids.ExecutionId;
+    readonly agent: Agent.Definition;
+    readonly input: ReadonlyArray<Content.Part>;
+    readonly resumeToolCall?: Tool.Call;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly startedAt: number;
+    readonly completedAt: number;
+}
+export interface RunResult {
+    readonly metadata: Shared.Metadata;
+    readonly nextEventSequence: Execution.ExecutionEventSequence;
+}
+export interface Interface {
+    readonly run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopWaitRequested>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/AgentLoop", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLog.Service | LanguageModelService.Service | ModelCallPolicy.Service | PromptAssembler.Service | ToolRuntime.Service>;
+export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
+export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | 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 "../../store-sql/index";
+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.AgentDefinitionId) => 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.AgentDefinitionId) => 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.AgentDefinitionId">) => 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.AgentDefinitionId">) => Effect.Effect<Agent.DefinitionRevisionList, AgentRegistryError, Service>;
+export {};

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

@@ -0,0 +1,102 @@
+import { Agent, Content, Shared, Tool } from "../../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as Ai from "effect/unstable/ai";
+import * as ArtifactStore from "../content/artifact-store-service";
+import * as BlobStore from "../content/blob-store-service";
+declare const PromptAssemblerError_base: Schema.Class<PromptAssemblerError, Schema.TaggedStruct<"PromptAssemblerError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * @experimental
+ */
+export declare class PromptAssemblerError extends PromptAssemblerError_base {
+}
+/**
+ * Everything an assembler may consider when building the turn-zero prompt.
+ *
+ * @experimental
+ */
+export interface AssembleInput {
+    readonly agent: Agent.Definition;
+    readonly tools: ReadonlyArray<Tool.Definition>;
+    readonly input: ReadonlyArray<Content.Part>;
+    /**
+     * Reserved truncation hook: when set, the assembler SHOULD keep the
+     * assembled prompt within this many tokens. The default layer ignores it
+     * (no tokenizer implementation exists yet); summarization/memory layers
+     * implement it later. Interface-only in v1.
+     */
+    readonly tokenBudget?: number;
+    readonly metadata?: Shared.Metadata;
+}
+/**
+ * @experimental
+ */
+export interface Assembled {
+    /** Content of the system message the chat is seeded with. */
+    readonly system: string;
+    /** The turn-zero prompt (typically one user message built from `input`). */
+    readonly prompt: Ai.Prompt.Prompt;
+}
+/**
+ * @experimental
+ */
+export interface Interface {
+    readonly assemble: (input: AssembleInput) => Effect.Effect<Assembled, PromptAssemblerError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/runtime/PromptAssembler", Interface>;
+/**
+ * @experimental
+ */
+export declare class Service extends Service_base {
+}
+/**
+ * Content parts whose conversion is pure — everything except the reference
+ * parts (`blob-reference`, `artifact-reference`), which are resolved
+ * effectfully through {@link BlobStore} / {@link ArtifactStore}.
+ *
+ * @experimental
+ */
+export type PureContentPart = Content.TextPart | Content.StructuredPart | Content.ToolCallPart | Content.ToolResultPart;
+/**
+ * Converts a pure Relay content part into an Effect AI user-message prompt part.
+ * Reference parts are resolved separately (see the default layer).
+ *
+ * @experimental
+ */
+export declare const contentToPromptPart: (part: PureContentPart) => Ai.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, BlobStore.Service | ArtifactStore.Service>;
+/**
+ * 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/child/child-run-service.d.ts

@@ -0,0 +1,90 @@
+import { Agent, Execution, Ids, Shared } from "../../schema/index";
+import { ChildExecutionRepository } from "../../store-sql/index";
+import { Context, Effect, Layer, Schema } from "effect";
+import * as EventLog 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 | EventLog.Service>;
+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 {};

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

@@ -0,0 +1,40 @@
+import { Content, Ids } from "../../schema/index";
+import { ChildExecutionRepository } from "../../store-sql/index";
+import { Context, Effect, Layer, Ref, Schema } from "effect";
+import * as EventLog from "../execution/event-log-service";
+import * as WaitService 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/ParentNotifier", 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, unknown>;
+}
+export declare const make: (options: MakeOptions) => Effect.Effect<Interface, never, ChildExecutionRepository.Service | EventLog.Service | WaitService.Service>;
+export declare const layerWith: (options: MakeOptions) => Layer.Layer<Service, never, ChildExecutionRepository.Service | EventLog.Service | WaitService.Service>;
+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 {};