effect-agent 0.1.0-beta.12 → 0.1.0-beta.121

package/dist/AgentPolicy-BqDoSXO6.d.mts

@@ -0,0 +1,96 @@
+import { n as ToolResultBounds } from "./ToolResult-BKdqWRff.mjs";
+import * as Schema from "effect/Schema";
+import * as Duration from "effect/Duration";
+declare namespace AgentPolicy_d_exports {
+  export { AgentPolicy, AgentPolicyInput, CompactionPolicy, CompactionPolicyInput };
+}
+declare const CompactionMode: Schema.Literals<readonly ["prune", "summarize", "prune-then-summarize"]>;
+/** Inputs normalized and validated by `CompactionPolicy.make`. */
+type CompactionPolicyInput = Readonly<{
+  /** Estimated tokens of recent history preserved verbatim across a compaction; defaults to `20_000`. */
+  readonly keepRecentTokens?: number;
+  /** Compaction strategy order; defaults to `"prune-then-summarize"`. */
+  readonly mode?: typeof CompactionMode.Type;
+}>;
+declare const CompactionPolicy_base: Schema.Class<CompactionPolicy, Schema.Struct<{
+  readonly keepRecentTokens: Schema.Int;
+  readonly mode: Schema.Literals<readonly ["prune", "summarize", "prune-then-summarize"]>;
+}>, {}>;
+/** How the engine reduces model context when `contextTokenLimit` is crossed. */
+declare class CompactionPolicy extends CompactionPolicy_base {
+  /** Normalize and validate compaction bounds, filling documented defaults. */
+  static make(input?: CompactionPolicyInput): CompactionPolicy;
+}
+/**
+ * Resolution when `maxTurns`, `maxToolCalls`, or `tokenBudget` is exhausted:
+ * `"final-answer"` gives the model one constrained opportunity to settle with
+ * output (the Run completes with `finishReason: "budget-exhausted"` and the
+ * exhausted-dimension marker), while `"fail"` fails the Run typed. Turn and
+ * Tool Call bounds resolve per RUN-018/RUN-019; the token dimension
+ * participates per RUN-025 with a one-shot bound (at most one grace call).
+ * Duration, cost, and repeated-failure bounds are hard rails regardless of
+ * this setting.
+ */
+declare const OnExhaustion: Schema.Literals<readonly ["final-answer", "fail"]>;
+declare const AgentPolicyFields: Schema.Struct<{
+  readonly maxTurns: Schema.Int;
+  readonly maxToolCalls: Schema.Int;
+  readonly maxDuration: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly toolConcurrency: Schema.Int;
+  readonly repeatedFailureLimit: Schema.Int;
+  readonly onExhaustion: Schema.Literals<readonly ["final-answer", "fail"]>;
+  readonly tokenBudget: Schema.optionalKey<Schema.Int>;
+  /** Tokens withheld from research calls so one final delivery call remains admissible. */
+  readonly completionReserveTokens: Schema.Int;
+  readonly costBudgetMicrousd: Schema.optionalKey<Schema.Int>;
+  /** Per-model-call live-context bound; crossing it triggers compaction rather than failure. */
+  readonly contextTokenLimit: Schema.optionalKey<Schema.Int>;
+  readonly toolResultBounds: typeof ToolResultBounds;
+  readonly runStatus: Schema.Literals<readonly ["appended", "off"]>;
+  readonly compaction: typeof CompactionPolicy;
+}>;
+type AgentPolicyFields = typeof AgentPolicyFields.Type;
+/** Inputs normalized and validated by `AgentPolicy.make`. */
+type AgentPolicyInput = Readonly<Omit<AgentPolicyFields, "maxDuration" | "repeatedFailureLimit" | "onExhaustion" | "toolResultBounds" | "runStatus" | "compaction" | "completionReserveTokens"> & {
+  /** Finite, positive wall-clock duration accepted in any Effect Duration input form. */
+  readonly maxDuration: Duration.Input;
+  /** Non-negative repeated-failure bound; defaults to `3`. */
+  readonly repeatedFailureLimit?: number;
+  /** Turn/Tool-Call/token exhaustion resolution; defaults to `"final-answer"`. */
+  readonly onExhaustion?: typeof OnExhaustion.Type;
+  /** Byte bound for each encoded Tool result; defaults to `50 KiB`. */
+  readonly toolResultBounds?: ToolResultBounds;
+  /** Whether a derived run-status message is appended to each model call; defaults to `"off"` to preserve retained prompt cache boundaries. */
+  readonly runStatus?: AgentPolicyFields["runStatus"];
+  /** Tokens reserved for final delivery; defaults to 20% of tokenBudget, capped at 4,096. */
+  readonly completionReserveTokens?: number;
+  /** Compaction strategy applied when `contextTokenLimit` is crossed; defaults documented on `CompactionPolicy`. */
+  readonly compaction?: CompactionPolicy;
+}>;
+declare const AgentPolicy_base: Schema.Class<AgentPolicy, Schema.Struct<{
+  readonly maxTurns: Schema.Int;
+  readonly maxToolCalls: Schema.Int;
+  readonly maxDuration: Schema.refine<Duration.Duration, Schema.Duration>;
+  readonly toolConcurrency: Schema.Int;
+  readonly repeatedFailureLimit: Schema.Int;
+  readonly onExhaustion: Schema.Literals<readonly ["final-answer", "fail"]>;
+  readonly tokenBudget: Schema.optionalKey<Schema.Int>;
+  /** Tokens withheld from research calls so one final delivery call remains admissible. */
+  readonly completionReserveTokens: Schema.Int;
+  readonly costBudgetMicrousd: Schema.optionalKey<Schema.Int>;
+  /** Per-model-call live-context bound; crossing it triggers compaction rather than failure. */
+  readonly contextTokenLimit: Schema.optionalKey<Schema.Int>;
+  readonly toolResultBounds: typeof ToolResultBounds;
+  readonly runStatus: Schema.Literals<readonly ["appended", "off"]>;
+  readonly compaction: typeof CompactionPolicy;
+}>, {}>;
+/** Schema class for finite agent run limits. */
+declare class AgentPolicy extends AgentPolicy_base {
+  /** Resolve an optional declaration against finite standalone or parent defaults. */
+  static resolve(input?: Partial<AgentPolicyInput>, parent?: AgentPolicy): AgentPolicy;
+  /** Normalize and validate finite policy bounds, throwing on invalid input. */
+  static make(input: AgentPolicyInput): AgentPolicy;
+}
+//#endregion
+export { CompactionPolicyInput as a, CompactionPolicy as i, AgentPolicyInput as n, AgentPolicy_d_exports as r, AgentPolicy as t };
+//# sourceMappingURL=AgentPolicy-BqDoSXO6.d.mts.map

package/dist/AgentRuntime-BUxDdLpw.d.mts

@@ -0,0 +1,346 @@
+import { d as ToolCallId, r as DelegationId, s as RunId, t as AgentId, u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { i as SubagentBudgetReservation, l as SubagentGrant, u as SubagentParentLink } from "./SubagentContract-DdT7Cqe6.mjs";
+import { i as UpdateError, n as Emitter } from "./AgentUpdates-DMJ-_xow.mjs";
+import { c as RunUsageReport, s as RunTotals } from "./Usage-Dx0aknfk.mjs";
+import { l as RunEvent } from "./RunEvent-DIrzkjLr.mjs";
+import { n as ThreadHistoryError, t as ThreadHistory } from "./ThreadHistory-tS1KwxHR.mjs";
+import { n as CurrentToolCatalog } from "./ToolExposure-UCN12eCd.mjs";
+import { s as ToolBroker } from "./ToolBroker-DWs4tZra.mjs";
+import { a as AgentInputError, c as AgentPolicyError, d as AgentToolAuthorizationDenied, f as ContextBudgetError, m as ModelProtocolError, n as AgentApprovalPending, p as ContextOverflowError, s as AgentOutputError, t as AgentApprovalDenied, u as AgentToolAuthorizationCheckError } from "./AgentError-Bn1ytXRD.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
+import { A as ToolUnion, C as OutputSchema, D as RunDispositionFailure, E as RunDispositionDeclaration, N as UpdatesSchema, O as RunDispositionSchema, S as Output, _ as InstructionSource, a as CompletionFromToolDeclaration, c as Definition, d as EncodedInput, f as Failure, m as InputPromptSource, n as Any, r as AnyDefinition, s as CompletionToolDeclaration, t as Agent_d_exports, w as Requirements } from "./Agent-D9cXqfF3.mjs";
+import { a as WorkerBudgetScope } from "./Worker-fwWkBg12.mjs";
+import { a as ContextWindow } from "./ContextWindow-DRQ5Mbm2.mjs";
+import { n as CompactionError } from "./ContextCompactor-WwSIG_Z2.mjs";
+import { t as DurableStep } from "./DurableStep-Cry_iol4.mjs";
+import { B as RunSubagentChildIdentity, H as RunSubagentEstablishRequest, M as RunOptions, S as RunContextPreparationError, W as RunSubagentJoinRequest, i as ChildEstablishStatus, l as ModelUsageAccounting, t as AgentUpdateAcceptance, x as RunContextPreparation } from "./RunOptions-CSBsSj0X.mjs";
+import { t as MessagingHost } from "./MessagingHost-CqzpxbGz.mjs";
+import { o as SubagentHost } from "./SubagentHost-4WB8Hj0C.mjs";
+import { t as RunEventSink } from "./RunEventSink-D5aVhISG.mjs";
+import { AiError, LanguageModel, Model, Prompt, Tool, Toolkit } from "effect/unstable/ai";
+import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream, Tracer } from "effect";
+//#region src/engine/internal/tool-telemetry.d.ts
+interface ToolSpanTelemetryService {
+  /** Measure one Tool handler attempt while isolating every host span-lifecycle defect. */
+  readonly isolateSpanLifecycle: <A, E, R>(stream: Stream.Stream<A, E, R>) => Stream.Stream<A, E, R>;
+  /** Effect counterpart used by programmatic Tool handlers nested inside an outer Tool stream. */
+  readonly isolateEffectSpanLifecycle: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+  /** Keep Effect AI implementation annotations local while preserving host-owned handler spans. */
+  readonly isolateToolkitHandle: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}
+declare const ToolSpanTelemetry_base: Context.ServiceClass<ToolSpanTelemetry, "@effect-agent/engine/ToolSpanTelemetry", ToolSpanTelemetryService>;
+/**
+ * @internal Engine-owned span-lifecycle policy. The AgentRuntime composition boundary builds this
+ * capability from the host's ambient Tracer; Tool execution consumes it without selecting,
+ * decorating, or locally providing a Tracer implementation.
+ */
+declare class ToolSpanTelemetry extends ToolSpanTelemetry_base {
+  static readonly layer: Layer.Layer<ToolSpanTelemetry>;
+}
+//#endregion
+//#region src/engine/internal/agent-runtime.d.ts
+type RuntimeProgram<InputSchema extends Schema.Top, OutputSchema extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, InstructionError = InstructionErrorOf<Instructions, InputSchema["Type"]>, InstructionRequirements = InstructionRequirementsOf<Instructions, InputSchema["Type"]>, RunDispositionValue extends RunDispositionDeclaration<OutputSchema["Type"], Schema.Top> | undefined = undefined, InputPromptValue extends InputPromptSource<InputSchema["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined> = {
+  readonly definition: Definition<InputSchema, OutputSchema, Instructions, Toolkit.Toolkit<Tools>, RunDispositionValue, InputPromptValue, UpdatesSchema> & {
+    readonly instructions: InstructionSource<InputSchema["Type"], NoInfer<InstructionError>, NoInfer<InstructionRequirements>>;
+    readonly inputPrompt?: InputPromptValue | undefined;
+  };
+};
+/**
+ * Structural shape of an Agent Binding accepted by the interpreter and by
+ * `AgentSpawner.spawn`: a model-agnostic Definition paired with an explicit
+ * native model Layer whose requirements stay visible. The Layer must provide
+ * LanguageModel, ProviderName, and ModelName, including after requirement capture.
+ */
+type RuntimeBinding<InputSchema extends Schema.Top, OutputSchema extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, _Provider, ModelProvides, ModelRequires, InstructionError = InstructionErrorOf<Instructions, InputSchema["Type"]>, InstructionRequirements = InstructionRequirementsOf<Instructions, InputSchema["Type"]>, RunDispositionValue extends RunDispositionDeclaration<OutputSchema["Type"], Schema.Top> | undefined = undefined, InputPromptValue extends InputPromptSource<InputSchema["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined> = RuntimeProgram<InputSchema, OutputSchema, Instructions, Tools, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema> & {
+  readonly model: Layer.Layer<LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName | ModelProvides, never, ModelRequires>;
+};
+type InstructionResultOf<Instructions, Input> = Instructions extends ((input: Input) => infer Result) ? Result : Instructions;
+type InstructionErrorOf<Instructions, Input> = InstructionResultOf<Instructions, Input> extends Effect.Effect<infer _Success, infer Error, infer _Requirements> ? Error : never;
+type InstructionRequirementsOf<Instructions, Input> = InstructionResultOf<Instructions, Input> extends Effect.Effect<infer _Success, infer _Error, infer Requirements> ? Requirements : never;
+type InputPromptErrorOf<InputPromptValue, Input> = InputPromptValue extends ((input: Input) => infer Result) ? Result extends Effect.Effect<infer _Success, infer Error, infer _Requirements> ? Error : never : never;
+type InputPromptRequirementsOf<InputPromptValue, Input> = InputPromptValue extends ((input: Input) => infer Result) ? Result extends Effect.Effect<infer _Success, infer _Error, infer Requirements> ? Requirements : never : never;
+/** Schema factory for the terminal value produced by reducing a completed agent event stream. */
+declare const AgentResultSchema: <Output extends Schema.Top>(output: Output) => Schema.Struct<{
+  readonly output: Output;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly turns: Schema.Int;
+  readonly finishReason: Schema.Literals<readonly ["completed", "model-stop", "budget-exhausted"]>;
+  /** Dimension that bound when the Run settled budget-exhausted (RUN-025; the grant-flow marker). */
+  readonly exhausted: Schema.optionalKey<Schema.Literals<readonly ["tokens", "tool-calls", "turns"]>>;
+  /** Schema-encoded application disposition declared for an ordinary completed Run. */
+  readonly runDisposition: Schema.optionalKey<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+  /** Cumulative spend for the Run, as reported on its terminal event. */
+  readonly usage: Schema.optionalKey<typeof RunTotals>;
+  /** Disjoint usage of attached descendants, including nested and failed children. */
+  readonly delegatedUsage: Schema.optionalKey<typeof RunTotals>;
+}>;
+/** Decoded terminal value produced by reducing a completed agent event stream. */
+type AgentResult<Output> = ReturnType<typeof AgentResultSchema<Schema.Schema<Output>>>["Type"];
+/** Expected agent, policy, and model-protocol failures exposed by the runtime. */
+type AgentRuntimeFailure<AgentValue extends AnyDefinition | Any, HookError = never, InstructionError = never> = Failure<AgentValue> | ([UpdatesSchema<AgentValue>] extends [never] ? never : UpdateError) | AgentPolicyError | ContextBudgetError | ContextOverflowError | CompactionError | RunContextPreparationError | AgentToolAuthorizationCheckError | ModelProtocolError | AgentApprovalDenied | AgentToolAuthorizationDenied | AgentApprovalPending | AgentChildPending | ThreadHistoryError | HookError | InstructionError;
+/**
+ * Services the engine itself provides locally to every Run: `AgentSpawner`
+ * bound to the Run's immutable identity and delegation depth, `RunEventSink`
+ * and `SubagentDurability` bound to the active Tool batch, `DurableStep`
+ * bound to the active Tool Call, and `ToolSpanTelemetry` bound at the Run
+ * composition edge. They are excluded from the runtime's public
+ * requirements and MUST NOT be satisfied from an application Layer.
+ */
+type EngineProvidedToolServices = Emitter | AgentSpawner | RunEventSink | DurableStep | SubagentDurability | SubagentHost | MessagingHost | ToolBroker | ToolSpanTelemetry | ContextWindow | CurrentToolCatalog;
+/** Schema services needed to reconstruct a completion Tool's canonical Agent output. */
+type AgentCompletionProjectionRequirements<AgentValue extends AnyDefinition | Any> = OutputSchema<AgentValue>["DecodingServices"] | OutputSchema<AgentValue>["EncodingServices"] | Tool.ParametersSchema<ToolUnion<AgentValue>>["DecodingServices"] | Tool.SuccessSchema<ToolUnion<AgentValue>>["DecodingServices"];
+/**
+ * Inferred agent services plus the runtime's identity and Thread history authorities.
+ * Engine-provided Tool handler services are excluded because the interpreter
+ * supplies them itself, bound to the current Run's identity. Tool parameter
+ * encoding, output decoding, and completion-projection Schema services stay
+ * listed unexcluded: the interpreter records canonical parameters before the
+ * handler boundary, `run`/`start` re-decode terminal output, and durable recovery
+ * re-decodes canonical completion Tool parameters/results.
+ */
+type AgentRuntimeRequirements<AgentValue extends AnyDefinition | Any, HookRequirements = never, InstructionRequirements = never> = Exclude<Requirements<AgentValue>, EngineProvidedToolServices> | Tool.ParametersSchema<ToolUnion<AgentValue>>["EncodingServices"] | AgentCompletionProjectionRequirements<AgentValue> | OutputSchema<AgentValue>["DecodingServices"] | ThreadHistory | HookRequirements | InstructionRequirements;
+/** Render decoded Agent input for model visibility, preserving the legacy JSON default. */
+declare function renderInputPrompt<Input, InputPromptValue extends InputPromptSource<NoInfer<Input>, unknown, unknown> | undefined>(inputPrompt: InputPromptValue, decodedInput: Input, encodedInput: unknown): Effect.Effect<Prompt.RawInput, AgentInputError | InputPromptErrorOf<InputPromptValue, Input>, InputPromptRequirementsOf<InputPromptValue, Input>>;
+declare const decodeFinalOutput: <AgentValue extends Any>(agent: AgentValue, text: string) => Effect.Effect<{
+  readonly encoded: Schema.Json;
+  readonly decoded: Output<AgentValue>;
+}, AgentOutputError, OutputSchema<AgentValue>["DecodingServices"]>;
+declare const projectCompletionOutput: <AgentValue extends Any>(agent: AgentValue, declaration: CompletionToolDeclaration<unknown, unknown, unknown>, parameters: unknown, result: unknown) => Effect.Effect<{
+  encoded: Schema.Json;
+  decoded: unknown;
+}, AgentOutputError | ModelProtocolError, unknown>;
+/** Reconstruct optional action completion identically for live execution and canonical recovery. */
+declare const projectCompletionFromToolOutput: <AgentValue extends Any>(agent: AgentValue, declaration: CompletionFromToolDeclaration<unknown, unknown, unknown>, parameters: unknown, result: unknown) => Effect.Effect<Option.None<{
+  encoded: Schema.Json;
+  decoded: unknown;
+}> | Option.Some<{
+  encoded: Schema.Json;
+  decoded: unknown;
+}>, AgentOutputError | ModelProtocolError, unknown>;
+declare function encodeRunDisposition<AgentValue extends Any>(agent: AgentValue, output: Output<AgentValue>): Effect.Effect<Schema.Json | undefined, RunDispositionFailure<AgentValue>, RunDispositionSchema<AgentValue>["EncodingServices"]>;
+/**
+ * Scoped detached execution whose observers cannot backpressure Run
+ * completion.
+ *
+ * `observe` is a live multicast subscription: each subscription replays every
+ * event the Run has already emitted, follows subsequent events as they occur,
+ * and ends once the Run settles. The finite Run event ceiling sizes the replay
+ * buffer so events are never dropped for a slow subscriber and publishing
+ * never blocks the Run. `events` remains the complete bounded replay,
+ * available after settlement. Both belong to the `start` Scope; observing
+ * after that Scope closes interrupts the observer.
+ */
+interface DetachedRun<Output, Error> {
+  readonly await: Effect.Effect<AgentResult<Output>, Error>;
+  readonly events: Effect.Effect<ReadonlyArray<RunEvent>>;
+  readonly observe: Stream.Stream<RunEvent>;
+  /** Snapshot of observed usage, also available after failure, defect, or interruption. Read after
+   * await settles (or the owning Scope closes) for a final report. In-flight work may be unpriced. */
+  readonly usageReport: Effect.Effect<RunUsageReport>;
+}
+/** Executable definitions or explicit per-agent model Layers for registration and delegation. */
+type ExecutableDefinition = AnyDefinition & {
+  readonly instructions: InstructionSource<never, unknown, unknown>;
+};
+type ExecutableAgent = ExecutableDefinition | {
+  readonly definition: ExecutableDefinition;
+  readonly model: Layer.Layer<LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName, never, unknown>;
+};
+/** Decode external input before instructions or model execution. */
+declare const streamUnknown: <A extends ExecutableAgent, H = never, R = never>(agent: A, input: unknown, options?: RunOptions<H, R>) => Stream.Stream<RunEvent, AgentRuntimeFailure<A, H>, AgentRuntimeRequirements<A, R>>;
+/**
+ * Host interpreter entry point with Attempt-local usage accounting and update acceptance in R.
+ * Durable coordinators provide these services alongside their recovery hooks;
+ * ordinary callers use streamUnknown's explicit ephemeral composition.
+ */
+declare const streamWithUsageAccountingUnknown: <A extends ExecutableAgent, H = never, R = never>(agent: A, input: unknown, options?: RunOptions<H, R>) => Stream.Stream<RunEvent, AgentRuntimeFailure<A, H>, AgentRuntimeRequirements<A, R> | ModelUsageAccounting | AgentUpdateAcceptance>;
+/** Accept schema-encoded input, retaining runtime validation. Use streamUnknown for external data. */
+declare const stream: <A extends ExecutableAgent, H = never, R = never>(agent: A, input: NoInfer<EncodedInput<A>>, options?: RunOptions<H, R>) => Stream.Stream<RunEvent, AgentRuntimeFailure<A, H>, AgentRuntimeRequirements<A, R>>;
+/** Decode external input before instructions or model execution. */
+declare function runUnknown<A extends ExecutableAgent, H = never, R = never>(agent: A, input: unknown, options?: RunOptions<H, R>): Effect.Effect<AgentResult<Output<A>>, AgentRuntimeFailure<A, H>, AgentRuntimeRequirements<A, R>>;
+/** Accept schema-encoded input, retaining runtime validation. Use runUnknown for external data. */
+declare const run: <A extends ExecutableAgent, H = never, R = never>(agent: A, input: NoInfer<EncodedInput<A>>, options?: RunOptions<H, R>) => Effect.Effect<AgentResult<Output<A>>, AgentRuntimeFailure<A, H>, AgentRuntimeRequirements<A, R>>;
+/** Decode external input before instructions or model execution. */
+declare function startUnknown<A extends ExecutableAgent, H = never, R = never>(agent: A, input: unknown, options?: RunOptions<H, R>): Effect.Effect<DetachedRun<Output<A>, AgentRuntimeFailure<A, H>>, never, AgentRuntimeRequirements<A, R> | Scope.Scope>;
+/** Accept schema-encoded input, retaining runtime validation. Use startUnknown for external data. */
+declare const start: <A extends ExecutableAgent, H = never, R = never>(agent: A, input: NoInfer<EncodedInput<A>>, options?: RunOptions<H, R>) => Effect.Effect<DetachedRun<Output<A>, AgentRuntimeFailure<A, H>>, never, AgentRuntimeRequirements<A, R> | Scope.Scope>;
+/**
+ * Immutable parent Run identity carried by the locally provided
+ * `AgentSpawner`. It exposes no mutable engine state and no Layer Context.
+ */
+interface AgentSpawnerParent {
+  readonly agentId: AgentId;
+  readonly threadId: ThreadId;
+  readonly runId: RunId;
+}
+declare const ToolCallWaiting_base: Schema.Class<ToolCallWaiting, Schema.TaggedStruct<"ToolCallWaiting", {
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+  readonly childRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly receiptId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ReceiptId">;
+  readonly message: Schema.String;
+}>, Cause.YieldableError>;
+/**
+ * Typed engine-owned suspension signal raised by a delegation Tool handler
+ * through the per-batch `SubagentDurability` service when its durable child
+ * is established but not settled (S2 plan §2). It is NOT a Tool failure: the
+ * batch executor treats the raising call as "stays open" — no terminal
+ * result, no `ToolCallFailed`, no batch failure policy, no sibling
+ * interruption — and terminates the Run with `AgentChildPending` after every
+ * non-waiting sibling handler settled.
+ */
+declare class ToolCallWaiting extends ToolCallWaiting_base {}
+declare const AgentChildPending_base: Schema.Class<AgentChildPending, Schema.TaggedStruct<"AgentChildPending", {
+  readonly children: Schema.NonEmptyArray<Schema.Struct<{
+    readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+    readonly childThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    readonly childSubmissionId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SubmissionId">;
+    readonly childRunId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  }>>;
+  readonly message: Schema.String;
+}>, Cause.YieldableError>;
+/**
+ * The Run suspended `waitingForChild`: at least one durable delegation call
+ * of the last Tool batch is waiting on its attached child.
+ * Mirrors `AgentApprovalPending`: the engine emits
+ * `RunSuspended` and then fails the Run stream with this error; the durable
+ * coordinator catches it and ends the Attempt's ownership period without
+ * settling. `children` is listed in declaration order, deterministically.
+ */
+declare class AgentChildPending extends AgentChildPending_base {}
+declare const SubagentDurabilityError_base: Schema.Class<SubagentDurabilityError, Schema.TaggedStruct<"SubagentDurabilityError", {
+  readonly operation: Schema.Literals<readonly ["establish", "join", "waiting"]>;
+  readonly reason: Schema.Literals<readonly ["hook-failed", "no-active-tool-batch"]>;
+  readonly message: Schema.String;
+  readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">>;
+  /** Diagnostic cause for the live Effect only; Run events retain the fixed public message. */
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, Cause.YieldableError>;
+/**
+ * Typed failure of the engine-provided `SubagentDurability` operations.
+ * `hook-failed` wraps a coordinator hook failure without leaking the hook's
+ * error type into handler signatures (the `DurableStepError` precedent);
+ * `no-active-tool-batch` is the fail-closed Run-level default — establishment
+ * outside an active Tool batch never silently degrades to ephemeral spawning.
+ */
+declare class SubagentDurabilityError extends SubagentDurabilityError_base {}
+/**
+ * Explicit ephemeral mode: no durable coordinator supplied
+ * `RunOptions.subagent`, so no durable claim is being made and the delegation
+ * handler keeps the S1 in-process spawn semantics honestly.
+ */
+interface SubagentDurabilityEphemeral {
+  readonly mode: "ephemeral";
+}
+/**
+ * Durable mode: establishment and join run through the coordinator's
+ * `RunSubagentHook` under the parent's ownership fence, and `waiting` raises
+ * the engine-owned suspension signal for a still-running child.
+ */
+interface SubagentDurabilityDurable {
+  readonly mode: "durable";
+  /** Idempotent durable child establishment under the parent ownership fence. */
+  readonly establish: (request: RunSubagentEstablishRequest) => Effect.Effect<ChildEstablishStatus, SubagentDurabilityError>;
+  /** Atomic settlement join: `SubagentJoined` + parent `ToolCallSettled` in one canonical batch (SUB-019). */
+  readonly join: (request: RunSubagentJoinRequest) => Effect.Effect<void, SubagentDurabilityError>;
+  /**
+   * Raise the waiting suspension signal for one delegation call whose
+   * established child has not settled. Never returns: the handler ends here,
+   * siblings run to completion, the Run suspends, and the resumed batch
+   * re-executes the handler idempotently.
+   */
+  readonly waiting: (toolCallId: ToolCallId, child: RunSubagentChildIdentity) => Effect.Effect<never, ToolCallWaiting | SubagentDurabilityError>;
+}
+/**
+ * Mode-dispatched service value seen by delegation Tool handlers: an explicit
+ * ephemeral default when the Run carries no durable coordinator, the durable
+ * establish/join/waiting surface otherwise.
+ */
+type SubagentDurabilityService = SubagentDurabilityEphemeral | SubagentDurabilityDurable;
+declare const SubagentDurability_base: Context.ServiceClass<SubagentDurability, "@effect-agent/engine/SubagentDurability", SubagentDurabilityService>;
+/**
+ * Engine-owned durable-Subagent seam provided locally to every Tool batch,
+ * constructed from `RunOptions.subagent` when present and the explicit
+ * ephemeral-mode default when absent. Like the other engine-provided Tool
+ * services it is excluded from the runtime's public requirements and MUST NOT
+ * be satisfied from an application Layer; handlers resolve it per call (the
+ * S1 innermost re-provide pattern) so a Layer built inside another Run's
+ * batch never captures a stale mode.
+ */
+declare class SubagentDurability extends SubagentDurability_base {}
+/** Stable delegation identity supplied by the invoking delegation Tool handler. */
+interface SpawnDelegation {
+  readonly delegationId: DelegationId;
+  readonly parentToolCallId: ToolCallId;
+}
+/**
+ * Child Run options accepted by `AgentSpawner.spawn`. Child Thread/Run
+ * identity and the Parent Link are spawner-owned and cannot be overridden.
+ */
+interface SpawnRunOptions<HookError = never, HookRequirements = never> extends Omit<RunOptions<HookError, HookRequirements>, "threadId" | "runId" | "parentLink"> {}
+/**
+ * Handle to one spawned Attached Child: its preallocated child identity, its
+ * immutable Parent Link, and the same observation surface as `DetachedRun`.
+ * The child fiber belongs to the Scope the caller provided to `spawn`.
+ */
+interface SpawnedChildRun<Output, Error> extends DetachedRun<Output, Error> {
+  readonly threadId: ThreadId;
+  readonly runId: RunId;
+  readonly parentLink: SubagentParentLink;
+}
+/**
+ * Narrow parent execution value visible to Tool handlers. `depth` is the
+ * current Run's root-relative delegation depth: `0` for a root Run and
+ * `parentLink.depth` for a child, which the delegation preflight uses to
+ * enforce inherited nesting ceilings and conserved subtree allocations.
+ */
+interface AgentSpawnerService {
+  /** Resolved defaults for this parent Run; never includes its tools or handlers. */
+  readonly policy: AgentPolicy;
+  readonly depth: number;
+  readonly grant?: SubagentGrant;
+  readonly budget?: SubagentBudgetReservation;
+  readonly budgetScope?: WorkerBudgetScope;
+  readonly parent: AgentSpawnerParent;
+  readonly spawn: <InputSchema extends Schema.Top, OutputSchema extends Schema.Top, Instructions, Tools extends Record<string, Tool.Any>, Provider, ModelProvides, ModelRequires, HookError = never, HookRequirements = never, InstructionError = InstructionErrorOf<Instructions, InputSchema["Type"]>, InstructionRequirements = InstructionRequirementsOf<Instructions, InputSchema["Type"]>, RunDispositionValue extends RunDispositionDeclaration<OutputSchema["Type"], Schema.Top> | undefined = undefined, InputPromptValue extends InputPromptSource<InputSchema["Type"], unknown, unknown> | undefined = undefined, UpdatesSchema extends Schema.Top | undefined = undefined>(binding: RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, input: unknown, delegation: SpawnDelegation, options?: SpawnRunOptions<HookError, HookRequirements>) => Effect.Effect<SpawnedChildRun<OutputSchema["Type"], AgentRuntimeFailure<RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, HookError, InstructionError>>, never, Scope.Scope | Exclude<AgentRuntimeRequirements<RuntimeBinding<InputSchema, OutputSchema, Instructions, Tools, Provider, ModelProvides, ModelRequires, InstructionError, InstructionRequirements, RunDispositionValue, InputPromptValue, UpdatesSchema>, HookRequirements, InstructionRequirements>, ThreadHistory | RunContextPreparation>>;
+}
+declare const AgentSpawner_base: Context.ServiceClass<AgentSpawner, "@effect-agent/engine/AgentSpawner", AgentSpawnerService>;
+/**
+ * Engine-owned service contract through which a declared delegation Tool
+ * runs an Attached Child on the same interpreter.
+ *
+ * The engine provides this service locally to every Run, bound to the Run's
+ * immutable identity and delegation depth; it is never satisfied from an
+ * application Layer, is excluded from the runtime's public requirements, and
+ * exposes neither the engine's mutable Run state nor any root Layer Context.
+ */
+declare class AgentSpawner extends AgentSpawner_base {}
+/**
+ * Opt-in boundary combinator (P7 §7(h), decision point 8): the engine keeps defects as
+ * defects — `RunFailed` covers EXPECTED failures only, and a defect still fails the event
+ * stream with its full Cause (AGENTS.md: errors are never silently widened, and a defect is
+ * never converted into a typed failure by default). A host boundary that forwards Run Events
+ * to a UI or transport can wrap the stream with this helper to append ONE bounded terminal
+ * `RunFailed { errorTag: "Defect" }` event before the original cause is rethrown, so a viewer
+ * always observes a terminal event even when the Run dies.
+ *
+ * Event contract:
+ *
+ * - typed failures and interruptions pass through untouched — the engine already emitted
+ *   their terminal event, so nothing is duplicated;
+ * - a cause carrying a defect first emits `RunFailed` with `errorTag: "Defect"` and a
+ *   bounded string rendering of the defect (never the raw value; hosts owning stricter
+ *   redaction apply it downstream), then RETHROWS the original cause unchanged;
+ * - identity fields come from the last event already streamed (`sequence` advances by one);
+ *   a defect BEFORE the first event has no Run identity to attribute, so it is rethrown
+ *   without an event — the helper never fabricates identities.
+ */
+declare const withTerminalDefectEvent: <E, R>(events: Stream.Stream<RunEvent, E, R>) => Stream.Stream<RunEvent, E, R>;
+declare namespace AgentRuntime_d_exports {
+  export { AgentChildPending, AgentCompletionProjectionRequirements, AgentResult, AgentResultSchema, AgentRuntimeFailure, AgentRuntimeRequirements, AgentSpawner, AgentSpawnerParent, AgentSpawnerService, DetachedRun, EngineProvidedToolServices, RuntimeBinding, SpawnDelegation, SpawnRunOptions, SpawnedChildRun, SubagentDurability, SubagentDurabilityDurable, SubagentDurabilityEphemeral, SubagentDurabilityError, SubagentDurabilityService, ToolCallWaiting, decodeFinalOutput, encodeRunDisposition, projectCompletionFromToolOutput, projectCompletionOutput, renderInputPrompt, run, runUnknown, start, startUnknown, stream, streamUnknown, streamWithUsageAccountingUnknown, withTerminalDefectEvent };
+}
+//#endregion
+export { start as A, decodeFinalOutput as C, renderInputPrompt as D, projectCompletionOutput as E, withTerminalDefectEvent as F, stream as M, streamUnknown as N, run as O, streamWithUsageAccountingUnknown as P, ToolCallWaiting as S, projectCompletionFromToolOutput as T, SubagentDurability as _, AgentResultSchema as a, SubagentDurabilityError as b, AgentSpawner as c, DetachedRun as d, EngineProvidedToolServices as f, SpawnedChildRun as g, SpawnRunOptions as h, AgentResult as i, startUnknown as j, runUnknown as k, AgentSpawnerParent as l, SpawnDelegation as m, AgentChildPending as n, AgentRuntimeFailure as o, RuntimeBinding as p, AgentCompletionProjectionRequirements as r, AgentRuntimeRequirements as s, AgentRuntime_d_exports as t, AgentSpawnerService as u, SubagentDurabilityDurable as v, encodeRunDisposition as w, SubagentDurabilityService as x, SubagentDurabilityEphemeral as y };
+//# sourceMappingURL=AgentRuntime-BUxDdLpw.d.mts.map