@relayfx/sdk 0.0.6 → 0.0.8

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

@@ -70,6 +70,17 @@ export declare const LocalAgentTarget: Schema.Struct<{
             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 skill_definition_ids: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.String, "Relay.SkillDefinitionId"> & {
+            make: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string & import("effect/Brand").Brand<"Relay.SkillDefinitionId">;
+        }>>;
+        readonly permission_rules: Schema.optionalKey<Schema.Struct<{
+            readonly rules: Schema.$Array<Schema.Struct<{
+                readonly pattern: Schema.String;
+                readonly level: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+                readonly reason: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly fallback: Schema.optionalKey<Schema.Literals<readonly ["allow", "deny", "ask"]>>;
+        }>>;
         readonly max_tool_turns: Schema.optionalKey<Schema.Int>;
         readonly max_wait_turns: Schema.optionalKey<Schema.Int>;
         readonly token_budget: Schema.optionalKey<Schema.Int>;
@@ -91,6 +102,10 @@ export declare const LocalAgentTarget: Schema.Struct<{
             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 handoff_targets: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly preset_name: 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>>>;
     }>;

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

@@ -1,16 +1,19 @@
 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 { Context, Effect, Layer, Schema } from "effect";
+import * as Ai from "effect/unstable/ai";
+import * as SpawnChildRunTool from "../child/spawn-child-run-tool";
 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 SchemaRegistry from "../schema-registry/schema-registry-service";
 import * as ToolRuntime from "../tool/tool-runtime-service";
 import * as PromptAssembler from "./prompt-assembler-service";
+import * as RelayCompaction 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>;
-}>, Cause.YieldableError>;
+}>, import("effect/Cause").YieldableError>;
 export declare class AgentLoopError extends AgentLoopError_base {
 }
 declare const AgentLoopWaitRequested_base: Schema.Class<AgentLoopWaitRequested, Schema.TaggedStruct<"AgentLoopWaitRequested", {
@@ -26,29 +29,33 @@ declare const AgentLoopWaitRequested_base: Schema.Class<AgentLoopWaitRequested,
         readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
     }>;
     readonly next_event_sequence: Schema.Int;
-}>, Cause.YieldableError>;
+}>, 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;
-}>, Cause.YieldableError>;
-/**
- * Raised when an agent's per-execution `token_budget` is reached. Checked
- * between turns at durable boundaries (never mid-stream); the execution fails
- * terminally, exactly like `AgentLoopError` (docs/spec/07 + ADR-0021).
- */
+}>, 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 agentDefinitionId?: Ids.AgentDefinitionId;
+    readonly agentDefinitionRevision?: Agent.DefinitionRevision;
     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?: RelayCompaction.Options | null;
+    readonly sessionEntryScope?: string;
+    readonly dispatchChildRun?: (input: SpawnChildRunTool.DispatchInput) => Effect.Effect<void, unknown, any>;
 }
 export interface RunResult {
     readonly metadata: Shared.Metadata;
@@ -68,7 +75,29 @@ export declare class Service extends Service_base {
  * @experimental
  */
 export declare const STRUCTURED_TURN_PROMPT = "Return the final structured output for the task above.";
-export declare const layer: Layer.Layer<Service, never, AgentChatRepository.Service | EventLog.Service | LanguageModelService.Service | ModelCallPolicy.Service | SchemaRegistry.Service | ToolRuntime.Service | PromptAssembler.Service>;
+/**
+ * Converts a Relay `Tool.Definition` into the `Ai.Tool` Baton's toolkit
+ * consumes. Exported for direct unit testing of the `needsApproval` mapping
+ * (see `agent-loop-service.test.ts`) — `Tool.Definition.needs_approval` must
+ * reach the constructed tool honestly so Relay tools self-describe correctly
+ * even outside Relay's own durable approval gate (docs/spec/27).
+ *
+ * @experimental
+ */
+/**
+ * Build the model-facing `Ai.Tool` from a bare `Tool.Definition`, delegating to
+ * the single canonical mapping in `ToolRuntime` so the parameters schema is a real
+ * object AST (not the `Schema.Unknown` placeholder that breaks OpenRouter/Anthropic
+ * tool preparation). Retained and exported only for the unit tests that assert the
+ * `needs_approval` mapping; the run loop builds its toolkit from `RegisteredTool`s
+ * (which may carry a tool's own concrete `aiTool`), not from definitions.
+ *
+ * @experimental
+ */
+export declare const aiToolFromDefinition: (definition: Tool.Definition) => Ai.Tool.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 | EventLog.Service | ToolRuntime.Service | LanguageModelService.Service | ModelCallPolicy.Service | SchemaRegistry.Service | PromptAssembler.Service>;
 export declare const testLayer: (implementation: Interface) => Layer.Layer<Service, never, never>;
 export declare const run: (input: RunInput) => Effect.Effect<RunResult, AgentLoopError | AgentLoopWaitRequested | AgentLoopBudgetExceeded, Service>;
 export {};

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

@@ -1,8 +1,20 @@
 import { Approvals } from "@batonfx/core";
 /**
- * Relay's binding for Baton's `Approvals` seam. No Relay tool definition carries
- * `needsApproval` today, so auto-approval leaves behavior unchanged; the file is
- * the named seam the durable-Wait-backed HITL implementation will replace.
+ * Relay's binding for Baton's `Approvals` seam: a DELIBERATE, PERMANENT
+ * auto-approving pass-through, not a placeholder.
+ *
+ * Decision authority for `needs_approval` tools lives one seam downstream, in
+ * the durable `ToolRuntime.run` gate (docs/spec/27-tool-approvals.md) — a
+ * deterministic `wait:approval:${tool_call_id}` row plus
+ * `tool.approval.requested` / `tool.approval.resolved` events. Baton dispatches
+ * a `needsApproval` tool call to `Approvals.check` first and, on `Approved`,
+ * hands off to `ToolExecutor.execute` (`RelayToolExecutor`, wrapping
+ * `ToolRuntime.run`) — where the REAL gate runs and suspends the call via
+ * Baton's `Suspend` outcome (`ToolExecutionWaitRequested`) until a decision is
+ * recorded. Auto-approving here just clears Baton's own pre-execution check so
+ * every call reaches that durable gate; it does not skip approval enforcement.
+ * Moving the gate into `Approvals.check` instead would change the durable
+ * event order that `test/e2e/tool-approval-durability.e2e.test.ts` depends on.
  *
  * @experimental
  */

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

@@ -0,0 +1,22 @@
+import { Compaction } from "@batonfx/core";
+import { Ids } from "../../schema/index";
+import { CompactionRepository } from "../../store-sql/index";
+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;
+}
+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,22 @@
+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>;
+/**
+ * Delivers the assembled turn-zero system prompt through Baton's `Instructions`
+ * seam instead of `Baton.Agent.RunOptions.system` (which makes Baton ignore its
+ * `Instructions` registry entirely). Only the assembled SYSTEM STRING moves
+ * through this seam — `PromptAssembler`'s blob/artifact prompt resolution has
+ * no Baton equivalent and remains a permanent Relay responsibility
+ * (docs/spec/28-prompt-assembly.md).
+ *
+ * Provided per-run, for fresh runs only: on resume, Baton ignores `Instructions`
+ * once `RunOptions.history` is set (the durable transcript already carries the
+ * assembled system message), so `agent-loop-service.ts` does not provide this
+ * layer on the resume branch.
+ *
+ * @experimental
+ */
+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 "../../store-sql/index";
+import { Effect, Layer } from "effect";
+import * as EventLog from "../execution/event-log-service";
+import * as WaitService 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: WaitService.Interface;
+    readonly eventLog: EventLog.Interface;
+    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 "../../store-sql/index";
+import { Effect, Layer } from "effect";
+import * as EventLog 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: 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

@@ -20,6 +20,9 @@ export interface Config {
     readonly permissions: ReadonlyArray<Tool.Permission>;
     readonly startedAt: number;
     readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly toolOutputMaxBytes?: number;
+    readonly resumedToolCallId?: Ids.ToolCallId;
+    readonly extraTools?: ReadonlyArray<ToolRuntime.RegisteredTool>;
 }
 /**
  * Baton `ToolExecutor` over Relay's `ToolRuntime`. Allocates sequences and maps

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 * as BlobStore from "../content/blob-store-service";
+export declare const store: (blobStore: BlobStore.Interface, toolCallId: string, content: unknown) => Effect.Effect<Option.Option<string>, ToolOutput.ToolOutputError>;
+export declare const make: (blobStore: BlobStore.Interface) => ToolOutput.StoreInterface;
+export declare const layerFromBlobStore: (blobStore: BlobStore.Interface) => Layer.Layer<ToolOutput.ToolOutputStore>;
+export declare const layer: Layer.Layer<ToolOutput.ToolOutputStore, never, BlobStore.Service>;

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

@@ -0,0 +1,209 @@
+import { Agent, Content, Execution, Ids, Shared } from "../../schema/index";
+import { Effect, Schema } from "effect";
+import * as EventLog from "../execution/event-log-service";
+import * as ToolRuntime from "../tool/tool-runtime-service";
+import * as WaitService from "../wait/wait-service";
+import * as ChildRunService 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 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 input: ReadonlyArray<Content.Part>;
+    readonly eventSequence: Execution.ExecutionEventSequence;
+    readonly startedAt: number;
+    readonly completedAt: number;
+    readonly agentDefinitionId: Ids.AgentDefinitionId;
+    readonly agentDefinitionRevision: Agent.DefinitionRevision;
+    readonly agentDefinitionSnapshot: Agent.Definition;
+    readonly metadata: Shared.Metadata;
+}
+export interface Config {
+    readonly agent: Agent.Definition;
+    readonly agentDefinitionId: Ids.AgentDefinitionId;
+    readonly agentDefinitionRevision: Agent.DefinitionRevision;
+    readonly childRuns: ChildRunService.Interface;
+    readonly eventLog: EventLog.Interface;
+    readonly waits: WaitService.Interface;
+    readonly dispatch: (input: DispatchInput) => Effect.Effect<void, unknown, any>;
+}
+export declare const enabled: (agent: Agent.Definition) => boolean;
+export declare const registeredTool: (config: Config) => ToolRuntime.RegisteredTool;
+export declare const transferToolName: (name: string) => string;
+export declare const transferTools: (config: Config) => ReadonlyArray<ToolRuntime.RegisteredTool>;