@relayfx/sdk 0.3.1 → 0.3.3

package/dist/sqlite.js

@@ -1,80 +1,27 @@
 // @bun
 import {
-  normalizeMigrationCause,
-  runtimeDatabaseLayer
-} from "./index-3sv8mmz5.js";
+  database,
+  normalizeMigrationCause
+} from "./index-49fm2rdv.js";
 import {
   DatabaseAlreadyOwned,
-  DatabaseDialect,
-  HostLayerError,
   RuntimeConfigurationError,
   RuntimeMigrationError,
   RuntimeTopologyError,
   SchemaHeadMismatch,
-  exports_client,
-  exports_operation,
-  exports_runtime,
-  makeDatabaseIdentity
-} from "./index-9k4k3wq1.js";
-import {
-  __export,
-  exports_activity_version_registry,
-  exports_address_book_service,
-  exports_address_resolution_service,
-  exports_address_schema,
-  exports_agent_loop_service,
-  exports_agent_registry_service,
-  exports_agent_schema,
-  exports_artifact_store_service,
-  exports_blob_store_service,
-  exports_child_fan_out_repository,
-  exports_child_fan_out_runtime,
-  exports_child_fan_out_transition_service,
-  exports_child_run_service,
-  exports_content_schema,
-  exports_definition_runtime,
-  exports_embedding_model_service,
-  exports_entity_schema,
-  exports_envelope_schema,
-  exports_envelope_service,
-  exports_event_log_service,
-  exports_execution_entity,
-  exports_execution_event_repository,
-  exports_execution_schema,
-  exports_execution_service,
-  exports_execution_workflow,
-  exports_ids_schema,
-  exports_language_model_service,
-  exports_model_call_policy,
-  exports_notification_bus,
-  exports_prompt_assembler_service,
-  exports_runner_runtime_service,
-  exports_schedule_schema,
-  exports_scheduler_service,
-  exports_schema_registry_service,
-  exports_shared_schema,
-  exports_skill_registry_service,
-  exports_skill_schema,
-  exports_tool_runtime_service,
-  exports_tool_schema,
-  exports_wait_service,
-  exports_workflow_definition_repository,
-  exports_workflow_schema
-} from "./index-c2skef55.js";
+  make,
+  makeDatabaseIdentity,
+  runtimeLayer
+} from "./index-8pa5e2yn.js";
+import"./index-25gwk9tj.js";
+import"./index-cphmds30.js";
+import"./index-nb39b5ae.js";
+
 // src/sqlite-runtime.ts
-var exports_sqlite_runtime = {};
-__export(exports_sqlite_runtime, {
-  workflowLayer: () => workflowLayer,
-  runtimeDatabaseLayer: () => runtimeDatabaseLayer2,
-  migrationsLayer: () => migrationsLayer,
-  layer: () => layer,
-  clientLayer: () => clientLayer,
-  childFanOutLayer: () => childFanOutLayer
-});
 import { layer as sqliteClientLayer } from "@effect/sql-sqlite-bun/SqliteClient";
-import { layer as sqliteMigratorLayer, run as runSqliteMigrator } from "@effect/sql-sqlite-bun/SqliteMigrator";
+import { run as runSqliteMigrator } from "@effect/sql-sqlite-bun/SqliteMigrator";
 import { layer as bunServicesLayer } from "@effect/platform-bun/BunServices";
-import { Cause, Effect as Effect2, FileSystem, Function, Layer, Path } from "effect";
+import { Effect as Effect2, FileSystem, Layer, Path } from "effect";
 import { SqlClient as SqlClient2 } from "effect/unstable/sql/SqlClient";
 
 // ../../migrations/sqlite/0001_baseline.sql
@@ -689,23 +636,38 @@ var canonicalFilename = Effect2.fn("SQLite.canonicalFilename")(function* (filena
   const absolute = path.resolve(filename);
   return yield* fs.realPath(absolute).pipe(Effect2.catch(() => fs.realPath(path.dirname(absolute)).pipe(Effect2.map((parent) => path.resolve(parent, path.basename(absolute))), Effect2.orElseSucceed(() => absolute))));
 });
-var runtimeDatabaseLayer2 = (options) => {
+var database2 = (options) => {
   if (options.filename.length === 0) {
-    return Object.assign(Layer.effectContext(Effect2.fail(RuntimeConfigurationError.make({
-      setting: "filename",
-      nextAction: "provide-setting",
-      cause: { _tag: "ConfigFailure", reason: "SQLite Runtime requires a non-empty filename" }
-    }))), { [DatabaseDialect]: "sqlite" });
+    const failure = RuntimeConfigurationError.make({
+      category: "database-config",
+      scope: "database-client",
+      cause: {
+        reasons: [{ _tag: "Fail", category: "database-config", errorTag: "RuntimeHostLayerFailure" }],
+        truncated: false
+      }
+    });
+    return make({
+      dialect: "sqlite",
+      migrate: Effect2.fail(failure),
+      verify: Effect2.fail(failure),
+      runtimeLayer: Layer.unwrap(Effect2.fail(failure))
+    });
   }
+  const memoryOwnerIdentity = options.filename === ":memory:" ? `sqlite:memory:${memoryIdentity++}` : undefined;
   const resolvedFilename = options.filename === ":memory:" ? Effect2.succeed(options.filename) : Effect2.scoped(Layer.build(bunServicesLayer).pipe(Effect2.flatMap((context) => Effect2.provide(canonicalFilename(options.filename), context))));
-  const database = Layer.unwrap(resolvedFilename.pipe(Effect2.map((filename) => makeSqliteDatabaseLayer(options, filename))));
-  return Object.assign(database, { [DatabaseDialect]: "sqlite" });
+  const resolveDatabase = resolvedFilename.pipe(Effect2.map((filename) => makeSqliteDatabase(options, filename, memoryOwnerIdentity)));
+  return make({
+    dialect: "sqlite",
+    runtimeLayer: Layer.unwrap(resolveDatabase.pipe(Effect2.map(runtimeLayer))),
+    migrate: resolveDatabase.pipe(Effect2.flatMap((value) => value.migrate)),
+    verify: resolveDatabase.pipe(Effect2.flatMap((value) => value.verify))
+  });
 };
-var makeSqliteDatabaseLayer = (options, filename) => {
-  const identity = options.filename === ":memory:" ? `sqlite:memory:${memoryIdentity++}` : `sqlite:file:${filename}`;
+var makeSqliteDatabase = (options, filename, memoryOwnerIdentity) => {
+  const identity = memoryOwnerIdentity ?? `sqlite:file:${filename}`;
   const databaseIdentity = makeDatabaseIdentity(identity);
-  const acquireSchema = Effect2.gen(function* () {
-    yield* runSqliteMigrator(migrationOptions).pipe((effect) => normalizeMigrationCause(effect, "sqlite", "apply"));
+  const migrateSchema = runSqliteMigrator(migrationOptions).pipe((effect) => normalizeMigrationCause(effect, "sqlite", "apply"));
+  const verifySchema = Effect2.gen(function* () {
     const sql = yield* SqlClient2;
     const rows = yield* sql`SELECT migration_id, name FROM relay_migrations ORDER BY migration_id`.pipe((effect) => normalizeMigrationCause(effect, "sqlite", "verify"));
     const actual = rows.map((row) => `${row.migration_id}:${row.name}`).join(",");
@@ -719,15 +681,17 @@ var makeSqliteDatabaseLayer = (options, filename) => {
       });
     }
   });
-  const database = runtimeDatabaseLayer({
+  const adapterDatabase = database({
     dialect: "sqlite",
     clientLayer: clientLayer({ ...options, filename }),
     databaseIdentity,
     ownership: "runtime-exclusive",
     schemaHead: String(migrations.at(-1)?.id ?? 0),
-    schema: acquireSchema
+    acquire: migrateSchema.pipe(Effect2.andThen(verifySchema)),
+    migrate: migrateSchema.pipe(Effect2.andThen(verifySchema)),
+    verify: verifySchema
   });
-  const ownership = Layer.effectDiscard(Effect2.acquireRelease(Effect2.suspend(() => {
+  const claim = Effect2.suspend(() => {
     if (ownedDatabases.has(identity)) {
       return Effect2.fail(RuntimeTopologyError.make({
         dialect: "sqlite",
@@ -738,99 +702,24 @@ var makeSqliteDatabaseLayer = (options, filename) => {
     }
     ownedDatabases.add(identity);
     return Effect2.void;
-  }), () => Effect2.sync(() => ownedDatabases.delete(identity))));
-  const ownedDatabase = database.pipe(Layer.provideMerge(ownership));
-  return ownedDatabase;
+  });
+  const release = () => Effect2.sync(() => ownedDatabases.delete(identity));
+  const ownership = Layer.effectDiscard(Effect2.acquireRelease(claim, release));
+  const withOwnership = (operation) => Effect2.scoped(Effect2.acquireRelease(claim, release).pipe(Effect2.andThen(operation)));
+  return make({
+    dialect: "sqlite",
+    migrate: withOwnership(adapterDatabase.migrate),
+    verify: withOwnership(adapterDatabase.verify),
+    runtimeLayer: runtimeLayer(adapterDatabase).pipe(Layer.provideMerge(ownership))
+  });
 };
 var migrationOptions = {
   loader,
   table: "relay_migrations"
 };
-var migrationsLayer = sqliteMigratorLayer(migrationOptions);
-var layer = (options) => {
-  const client = clientLayer(options);
-  return Layer.effect(SqlClient2, Effect2.gen(function* () {
-    const sql = yield* SqlClient2;
-    yield* runSqliteMigrator(migrationOptions);
-    return sql;
-  })).pipe(Layer.provide(client));
-};
-var isAcquisitionError = (error) => typeof error === "object" && error !== null && ("_tag" in error) && (error._tag === "RuntimeConfigurationError" || error._tag === "RuntimeTopologyError" || error._tag === "RuntimeMigrationError");
-var normalizeHostError = (error) => {
-  if (isAcquisitionError(error))
-    return error;
-  const hostFailure = HostLayerError.make({
-    service: "SQLite compatibility host graph",
-    reason: "host layer acquisition failed"
-  });
-  Object.defineProperty(hostFailure, "originalCause", { value: error, enumerable: false });
-  return RuntimeConfigurationError.make({
-    setting: "host layers",
-    nextAction: "provide-host-layer",
-    cause: hostFailure
-  });
-};
-var normalizeHostLayer = (source) => source.pipe(Layer.catchCause((cause) => {
-  if (Cause.hasInterrupts(cause))
-    return Layer.unwrap(Effect2.failCause(Cause.map(cause, normalizeHostError)));
-  return Layer.unwrap(Effect2.fail(normalizeHostError(Cause.squash(cause))));
-}));
-var workflowLayer = Function.dual(2, (options, handlersLayer) => {
-  const sqlite = layer(options);
-  const repository = exports_workflow_definition_repository.layer.pipe(Layer.provideMerge(sqlite));
-  return normalizeHostLayer(exports_definition_runtime.layer.pipe(Layer.provideMerge(handlersLayer), Layer.provideMerge(repository)));
-});
-var childFanOutLayer = Function.dual(2, (options, handlersLayer) => {
-  const sqlite = layer(options);
-  const repository = exports_child_fan_out_repository.layer.pipe(Layer.provideMerge(sqlite));
-  const events = exports_event_log_service.layerFromRepository.pipe(Layer.provide(exports_execution_event_repository.layer.pipe(Layer.provide(exports_notification_bus.inProcessLayer))), Layer.provideMerge(sqlite));
-  const transitions = exports_child_fan_out_transition_service.layer.pipe(Layer.provide(repository), Layer.provide(events));
-  return normalizeHostLayer(exports_child_fan_out_runtime.layer.pipe(Layer.provide(handlersLayer), Layer.provide(repository), Layer.provide(transitions)));
-});
 
 // src/sqlite.ts
-var relaySqlitePackage = "@relayfx/sdk/sqlite";
+var SQLite = { database: database2 };
 export {
-  relaySqlitePackage,
-  exports_definition_runtime as WorkflowDefinitionRuntime,
-  exports_workflow_schema as Workflow,
-  exports_wait_service as WaitService,
-  exports_tool_runtime_service as ToolRuntime,
-  exports_tool_schema as Tool,
-  exports_skill_registry_service as SkillRegistry,
-  exports_skill_schema as Skill,
-  exports_shared_schema as Shared,
-  exports_schema_registry_service as SchemaRegistry,
-  exports_scheduler_service as SchedulerService,
-  exports_schedule_schema as Schedule,
-  exports_sqlite_runtime as SQLite,
-  exports_runtime as Runtime,
-  exports_runner_runtime_service as RunnerRuntime,
-  exports_prompt_assembler_service as PromptAssembler,
-  exports_operation as Operation,
-  exports_model_call_policy as ModelCallPolicy,
-  exports_language_model_service as LanguageModelService,
-  exports_ids_schema as Ids,
-  exports_execution_workflow as ExecutionWorkflow,
-  exports_execution_service as ExecutionService,
-  exports_execution_entity as ExecutionEntity,
-  exports_execution_schema as Execution,
-  exports_event_log_service as EventLog,
-  exports_envelope_service as EnvelopeService,
-  exports_envelope_schema as Envelope,
-  exports_entity_schema as Entity,
-  exports_embedding_model_service as EmbeddingModelService,
-  exports_content_schema as Content,
-  exports_client as Client,
-  exports_child_run_service as ChildRunService,
-  exports_child_fan_out_runtime as ChildFanOutRuntime,
-  exports_blob_store_service as BlobStore,
-  exports_artifact_store_service as ArtifactStore,
-  exports_agent_registry_service as AgentRegistry,
-  exports_agent_loop_service as AgentLoop,
-  exports_agent_schema as Agent,
-  exports_address_resolution_service as AddressResolution,
-  exports_address_book_service as AddressBook,
-  exports_address_schema as Address,
-  exports_activity_version_registry as ActivityVersionRegistry
+  SQLite
 };

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

@@ -1,4 +1,5 @@
 export * as EmbeddingModelRegistration from "./embedding-model/embedding-model-registration";
 export * as LanguageModelRegistration from "./language-model/language-model-registration";
-export { Agent, AgentEvent, AgentTool, AiError, Approvals, Chat, Compaction, EmbeddingModel, Guardrail, Handoff, IdGenerator, Instructions, LanguageModel, Memory, Model, ModelMiddleware, ModelRegistry, ModelResilience, Permissions, Prompt, Response, ResponseIdTracker, Session, SkillSource, Steering, Telemetry, Tokenizer, Tool, ToolContext, ToolExecutor, Toolkit, ToolOutput, TurnPolicy, } from "@batonfx/core";
+export { Agent, AgentEvent, AgentTool, AiError, Approvals, Chat, Compaction, EmbeddingModel, Guardrail, Handoff, IdGenerator, Instructions, Memory, Model, ModelMiddleware, ModelRegistry, ModelResilience, Permissions, Prompt, Response, ResponseIdTracker, Session, SkillSource, Steering, Telemetry, Tokenizer, Tool, ToolContext, ToolExecutor, Toolkit, ToolOutput, TurnPolicy, } from "@batonfx/core";
+export * as LanguageModel from "effect/unstable/ai/LanguageModel";
 export declare const aiPackage = "./index";

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

@@ -1,10 +1,13 @@
+import { ModelRegistry } from "@batonfx/core";
+import type { Effect } from "effect";
 export type { AnthropicInput, WithAnthropicOptions } from "@batonfx/providers/anthropic";
-export { anthropic, anthropicClientLayerConfig, withAnthropic } from "@batonfx/providers/anthropic";
+export { anthropic, anthropicClientLayerConfig, withAnthropic, withAnthropicFetch } from "@batonfx/providers/anthropic";
 export type { DeterministicInput, WithOpenAiOrDeterministicOptions } from "@batonfx/providers/deterministic";
-export { deterministicModel, withDeterministic, withOpenAiOrDeterministic } from "@batonfx/providers/deterministic";
-export type { OpenAiInput, RegistrationOptions, WithOpenAiOptions } from "@batonfx/providers/openai";
-export { openAi, openAiClientLayerConfig, withOpenAi } from "@batonfx/providers/openai";
+export { withDeterministic, withOpenAiOrDeterministic, withOpenAiOrDeterministicFetch, } from "@batonfx/providers/deterministic";
+export declare const deterministicModel: (input: import("@batonfx/providers/deterministic").DeterministicInput) => Effect.Effect<ModelRegistry.Registration>;
+export type { OpenAiAccountCredential, OpenAiAccountCredentials, OpenAiAccountInput, OpenAiInput, RegistrationOptions, WithOpenAiOptions, } from "@batonfx/providers/openai";
+export { openAi, openAiAccount, OpenAiAccountCredentialError, openAiClientLayerConfig, withOpenAi, withOpenAiAccount, withOpenAiAccountFetch, withOpenAiFetch, } from "@batonfx/providers/openai";
 export type { OpenAiCompatibleInput, WithOpenAiCompatibleOptions } from "@batonfx/providers/openai-compat";
-export { openAiCompatible, openAiCompatibleClientLayerConfig, withOpenAiCompatible, } from "@batonfx/providers/openai-compat";
+export { openAiCompatible, openAiCompatibleClientLayerConfig, withOpenAiCompatible, withOpenAiCompatibleFetch, } from "@batonfx/providers/openai-compat";
 export type { OpenRouterInput, WithOpenRouterOptions } from "@batonfx/providers/openrouter";
-export { openRouter, openRouterClientLayerConfig, withOpenRouter } from "@batonfx/providers/openrouter";
+export { openRouter, openRouterClientLayerConfig, withOpenRouter, withOpenRouterFetch, } from "@batonfx/providers/openrouter";

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

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer } from "effect";
-import { ClientError, Service as ClientService, WaitKindMismatch } from "./client";
+import { ClientError, Service as ClientService, WaitKindMismatch } from "./client-public";
 import { AckEnvelopeReadyInput, ClaimEnvelopeReadyInput, EnvelopeReadyAcked, EnvelopeReadyLease, EnvelopeReadyReleased, ReleaseEnvelopeReadyInput, SubmitInboundEnvelopeAccepted, SubmitInboundEnvelopeInput } from "./operation";
 export interface Interface {
     readonly claim: (input: ClaimEnvelopeReadyInput) => Effect.Effect<EnvelopeReadyLease | null, ClientError>;

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

@@ -1,2 +1,34 @@
-export { Agent, AgentEvent, AgentTool, AiError, Approvals, Chat, Compaction, EmbeddingModel, Guardrail, Handoff, IdGenerator, Instructions, LanguageModel, Memory, Model, ModelMiddleware, ModelRegistry, ModelResilience, Permissions, Prompt, Response, ResponseIdTracker, Session, SkillSource, Steering, Telemetry, Tokenizer, Tool, ToolContext, ToolExecutor, Toolkit, ToolOutput, TurnPolicy, } from "../ai/index";
-export declare const relayAiPackage = "@relayfx/sdk/ai";
+import { Agent as BatonAgent, AgentEvent as BatonAgentEvent, AgentTool as BatonAgentTool, AiError as BatonAiError, Approvals as BatonApprovals, Chat as BatonChat, Compaction as BatonCompaction, EmbeddingModel as BatonEmbeddingModel, Guardrail as BatonGuardrail, Handoff as BatonHandoff, IdGenerator as BatonIdGenerator, Instructions as BatonInstructions, Memory as BatonMemory, Model as BatonModel, ModelMiddleware as BatonModelMiddleware, ModelRegistry as BatonModelRegistry, ModelResilience as BatonModelResilience, Permissions as BatonPermissions, Prompt as BatonPrompt, Response as BatonResponse, ResponseIdTracker as BatonResponseIdTracker, Session as BatonSession, SkillSource as BatonSkillSource, Steering as BatonSteering, Telemetry as BatonTelemetry, Tokenizer as BatonTokenizer, Tool as BatonTool, ToolContext as BatonToolContext, ToolExecutor as BatonToolExecutor, Toolkit as BatonToolkit, ToolOutput as BatonToolOutput, TurnPolicy as BatonTurnPolicy } from "@batonfx/core";
+export * as LanguageModel from "effect/unstable/ai/LanguageModel";
+export import Agent = BatonAgent;
+export import AgentEvent = BatonAgentEvent;
+export import AgentTool = BatonAgentTool;
+export import AiError = BatonAiError;
+export import Approvals = BatonApprovals;
+export import Chat = BatonChat;
+export import Compaction = BatonCompaction;
+export import EmbeddingModel = BatonEmbeddingModel;
+export import Guardrail = BatonGuardrail;
+export import Handoff = BatonHandoff;
+export import IdGenerator = BatonIdGenerator;
+export import Instructions = BatonInstructions;
+export import Memory = BatonMemory;
+export import Model = BatonModel;
+export import ModelMiddleware = BatonModelMiddleware;
+export import ModelRegistry = BatonModelRegistry;
+export import ModelResilience = BatonModelResilience;
+export import Permissions = BatonPermissions;
+export import Prompt = BatonPrompt;
+export import Response = BatonResponse;
+export import ResponseIdTracker = BatonResponseIdTracker;
+export import Session = BatonSession;
+export import SkillSource = BatonSkillSource;
+export import Steering = BatonSteering;
+export import Telemetry = BatonTelemetry;
+export import Tokenizer = BatonTokenizer;
+export import Tool = BatonTool;
+export import ToolContext = BatonToolContext;
+export import ToolExecutor = BatonToolExecutor;
+export import Toolkit = BatonToolkit;
+export import ToolOutput = BatonToolOutput;
+export import TurnPolicy = BatonTurnPolicy;

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

@@ -0,0 +1,5 @@
+import type { Interface as ChildFanOutRuntimeInterface } from "../runtime/child/child-fan-out-runtime";
+import { WorkflowRuntimeError as WorkflowDefinitionRuntimeWorkflowRuntimeError } from "../runtime/workflow/definition-runtime";
+import { Effect } from "effect";
+/** Admission follows confirmed persistence. A successful sweep means the fan-out was admitted or already settled. */
+export declare const recoverPersistedFanOut: (recover: ChildFanOutRuntimeInterface["recover"]) => Effect.Effect<void, WorkflowDefinitionRuntimeWorkflowRuntimeError>;

package/dist/types/relay/child-fan-out-host.d.ts

@@ -0,0 +1,73 @@
+import { ChildOrchestration, Ids } from "../schema/index";
+import { Context, Effect, Layer, Schema } from "effect";
+export declare const Result: Schema.Struct<{
+    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>>>;
+    }>]>>;
+    readonly error: Schema.optionalKey<Schema.String>;
+    readonly completed_at: Schema.optionalKey<Schema.Finite>;
+}>;
+export interface Result extends Schema.Schema.Type<typeof Result> {
+}
+declare const HandlerError_base: Schema.Class<HandlerError, Schema.TaggedStruct<"ChildFanOutHostHandlerError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class HandlerError extends HandlerError_base {
+}
+export interface Handlers {
+    readonly execute: (child: ChildOrchestration.FanOutChild, fanOut: ChildOrchestration.FanOutState, idempotencyKey: string) => Effect.Effect<Result, HandlerError>;
+    readonly cancel: (childExecutionId: Ids.ChildExecutionId, reason: string) => Effect.Effect<void, HandlerError>;
+}
+export type Interface = Handlers;
+declare const Service_base: Context.ServiceClass<Service, "@relayfx/sdk/child-fan-out-host/Service", Handlers>;
+export declare class Service extends Service_base {
+}
+export declare const layer: (handlers: Handlers) => Layer.Layer<Service, never, never>;
+export {};