effect-agent 0.1.0-beta.11 → 0.1.0-beta.111

package/dist/ToolResult-BKdqWRff.d.mts

@@ -0,0 +1,78 @@
+import * as Schema from "effect/Schema";
+import { AiError } from "effect/unstable/ai";
+declare namespace ToolResult_d_exports {
+  export { ToolParameterRejection, ToolResultBounds, TruncatedToolResult, UnserializableToolResult, applyToolResultBounds, unserializableToolResult };
+}
+/**
+ * Engine-owned evidence that a fresh model call failed parameter validation.
+ * Retain the exact JSON arguments beside the native error so recovery can distinguish
+ * a rejected request from damaged executable parameters. This never authorizes execution.
+ */
+declare const ToolParameterRejection: Schema.Struct<{
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  readonly parameters: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly error: Schema.toEncoded<Schema.Struct<{
+    readonly _tag: Schema.tag<"AiError">;
+    readonly module: Schema.String;
+    readonly method: Schema.String;
+    readonly reason: typeof AiError.ToolParameterValidationError;
+  }>>;
+}>;
+type ToolParameterRejection = typeof ToolParameterRejection.Type;
+declare const ToolResultBounds_base: Schema.Class<ToolResultBounds, Schema.Struct<{
+  readonly maxBytes: Schema.Int;
+}>, {}>;
+/** Byte bound applied to one encoded application Tool result before it enters history. */
+declare class ToolResultBounds extends ToolResultBounds_base {}
+declare const TruncatedToolResult_base: Schema.Class<TruncatedToolResult, Schema.Struct<{
+  readonly truncatedToolResult: Schema.Literal<true>;
+  readonly originalBytes: Schema.Natural;
+  readonly head: Schema.String;
+  readonly tail: Schema.String;
+}>, {}>;
+/**
+ * Canonical envelope replacing an encoded Tool result that exceeded its
+ * policy bounds. `head` and `tail` are an exact prefix and suffix of the
+ * original encoded JSON text; the middle is dropped, never paraphrased.
+ */
+declare class TruncatedToolResult extends TruncatedToolResult_base {}
+declare const UnserializableToolResult_base: Schema.Class<UnserializableToolResult, Schema.Struct<{
+  readonly unserializableToolResult: Schema.Literal<true>;
+  readonly reason: Schema.String;
+}>, {}>;
+/**
+ * Canonical fail-closed sentinel replacing an encoded Tool result that could
+ * not be JSON-serialized at all (cyclic value, BigInt, `undefined`, throwing
+ * `toJSON`). The original value never enters history or durable records —
+ * an unserializable value is unbounded by construction, so the bound seam
+ * replaces it wholesale rather than passing it through (runtime spec §9).
+ */
+declare class UnserializableToolResult extends UnserializableToolResult_base {}
+/**
+ * Build the encoded sentinel for a serialization failure. Total by
+ * construction — the cause is untrusted (a hostile `toString` or an
+ * accessor-backed `Error.message` can itself throw on this last-resort
+ * path) — and byte-bound: the complete encoded sentinel stays within the
+ * 256-byte `ToolResultBounds` schema floor, so it fits every accepted
+ * policy without the caller re-applying bounds.
+ */
+declare const unserializableToolResult: (cause: unknown) => typeof UnserializableToolResult.Encoded;
+/**
+ * Bound one encoded Tool result to `bounds.maxBytes` UTF-8 bytes.
+ *
+ * Within bounds the input is returned unchanged. Over bounds the result is
+ * the JSON-encoded `TruncatedToolResult` envelope preserving an exact prefix
+ * and suffix of the input, split ~50/50 across the byte budget left after
+ * the envelope's own overhead and shrunk deterministically until the encoded
+ * envelope itself fits. Slicing never splits a UTF-16 surrogate pair, so the
+ * envelope always re-encodes as valid JSON.
+ *
+ * The Schema-level 256-byte floor on `ToolResultBounds.maxBytes` guarantees
+ * every accepted bound fits the minimal envelope (at most 81 bytes), so the
+ * returned value never exceeds `maxBytes` for a decodable bound. The
+ * minimal-envelope fallback below survives purely as defense in depth.
+ */
+declare const applyToolResultBounds: (encodedJson: string, bounds: ToolResultBounds) => string;
+//#endregion
+export { UnserializableToolResult as a, TruncatedToolResult as i, ToolResultBounds as n, applyToolResultBounds as o, ToolResult_d_exports as r, unserializableToolResult as s, ToolParameterRejection as t };
+//# sourceMappingURL=ToolResult-BKdqWRff.d.mts.map

package/dist/Usage-Dx0aknfk.d.mts

@@ -0,0 +1,121 @@
+import { Effect, Schema } from "effect";
+declare namespace Usage_d_exports {
+  export { ChildRunUsage, InputTokenUsage, ModelCallUsage, ModelResponseIdentity, ModelUsageGroup, OutputTokenUsage, RunTotals, RunUsageReport, RunUsageSummary, UsageAggregationError, UsageCompleteness, emptyRunTotals, runTotalsFromSummary, sumRunTotals, summarizeModelUsage, unknownRunTotals };
+}
+declare const ModelResponseIdentity_base: Schema.Class<ModelResponseIdentity, Schema.Struct<{
+  readonly id: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly model: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/** Bounded provider response identity. Request configuration is not response evidence. */
+declare class ModelResponseIdentity extends ModelResponseIdentity_base {}
+/** Missing legacy status means unknown, never a free call or a complete report. */
+declare const UsageCompleteness: Schema.Literals<readonly ["complete", "partial", "unknown"]>;
+declare const InputTokenUsage_base: Schema.Class<InputTokenUsage, Schema.Struct<{
+  readonly total: Schema.Natural;
+  readonly uncached: Schema.Natural;
+  readonly cacheRead: Schema.Natural;
+  readonly cacheWrite: Schema.Natural;
+}>, {}>;
+/** Provider-reported input-token components for one completed model call. */
+declare class InputTokenUsage extends InputTokenUsage_base {}
+declare const OutputTokenUsage_base: Schema.Class<OutputTokenUsage, Schema.Struct<{
+  readonly total: Schema.Natural;
+  readonly text: Schema.Natural;
+  readonly reasoning: Schema.Natural;
+}>, {}>;
+/** Provider-reported output-token components for one completed model call. */
+declare class OutputTokenUsage extends OutputTokenUsage_base {}
+declare const ModelCallUsage_base: Schema.Class<ModelCallUsage, Schema.Struct<{
+  readonly provider: Schema.NonEmptyString;
+  /** Configured binding identity. See response.model for provider-reported identity. */
+  readonly model: Schema.NonEmptyString;
+  readonly serviceTier: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly pricingVersion: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly response: Schema.optionalKey<typeof ModelResponseIdentity>;
+  readonly purpose: Schema.optionalKey<Schema.Literals<readonly ["turn", "summary"]>>;
+  readonly usageStatus: Schema.optionalKey<Schema.Literals<readonly ["complete", "partial", "unknown"]>>;
+  readonly pricingStatus: Schema.optionalKey<Schema.Literals<readonly ["estimated", "unknown"]>>;
+  readonly inputTokens: typeof InputTokenUsage;
+  readonly outputTokens: typeof OutputTokenUsage;
+  readonly costMicrousd: Schema.Natural;
+}>, {}>;
+/** Canonical, provider-independent accounting for one completed model call. */
+declare class ModelCallUsage extends ModelCallUsage_base {}
+declare const RunTotals_base: Schema.Class<RunTotals, Schema.Struct<{
+  readonly modelCalls: Schema.Natural;
+  readonly inputTokens: Schema.Natural;
+  readonly outputTokens: Schema.Natural;
+  readonly costMicrousd: Schema.Natural;
+  readonly usageStatus: Schema.optionalKey<Schema.Literals<readonly ["complete", "partial", "unknown"]>>;
+  readonly pricingStatus: Schema.optionalKey<Schema.Literals<readonly ["complete", "partial", "unknown"]>>;
+  readonly unobservedModelCalls: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/**
+ * Observed model usage and estimated cost, without per-model attribution.
+ * Numeric zero with unknown coverage never establishes free execution. Missing legacy
+ * statuses mean unknown. Unobserved calls are excluded from the numeric call/token totals.
+ */
+declare class RunTotals extends RunTotals_base {}
+declare const RunUsageReport_base: Schema.Class<RunUsageReport, Schema.Struct<{
+  readonly usage: typeof RunTotals;
+  readonly delegatedUsage: typeof RunTotals;
+}>, {}>;
+/** Own Run usage and disjoint attached-descendant usage. Add each component once. */
+declare class RunUsageReport extends RunUsageReport_base {}
+declare const ChildRunUsage_base: Schema.Class<ChildRunUsage, Schema.Struct<{
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly report: typeof RunUsageReport;
+}>, {}>;
+/** A verified child report retained across durable parent Attempts. */
+declare class ChildRunUsage extends ChildRunUsage_base {}
+/** Known absence of observed work. */
+declare const emptyRunTotals: () => RunTotals;
+/** No accounting evidence, including legacy child reports. This is not known zero spend. */
+declare const unknownRunTotals: () => RunTotals;
+declare const ModelUsageGroup_base: Schema.Class<ModelUsageGroup, Schema.Struct<{
+  readonly provider: Schema.NonEmptyString;
+  readonly model: Schema.NonEmptyString;
+  /** Actual returned model; absent when only the configured binding is known. */
+  readonly responseModel: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly serviceTier: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly pricingVersion: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly modelCalls: Schema.Natural;
+  readonly inputTokens: typeof InputTokenUsage;
+  readonly outputTokens: typeof OutputTokenUsage;
+  readonly costMicrousd: Schema.Natural;
+}>, {}>;
+/** Settlement-sized aggregate for calls sharing one pricing identity. */
+declare class ModelUsageGroup extends ModelUsageGroup_base {}
+declare const RunUsageSummary_base: Schema.Class<RunUsageSummary, Schema.Struct<{
+  readonly modelCalls: Schema.Natural;
+  readonly inputTokens: typeof InputTokenUsage;
+  readonly outputTokens: typeof OutputTokenUsage;
+  readonly costMicrousd: Schema.Natural;
+  readonly byModel: Schema.$Array<typeof ModelUsageGroup>;
+  /** Coverage of recorded calls only; interruptions can make the Run less complete. */
+  readonly usageStatus: Schema.optionalKey<Schema.Literals<readonly ["complete", "partial", "unknown"]>>;
+  readonly pricingStatus: Schema.optionalKey<Schema.Literals<readonly ["complete", "partial", "unknown"]>>;
+  /** Observed invocations without retained accounting, excluded from numeric call/token totals. */
+  readonly unobservedModelCalls: Schema.optionalKey<Schema.Natural>;
+}>, {}>;
+/** Settlement aggregate included with a terminal Run settlement. */
+declare class RunUsageSummary extends RunUsageSummary_base {}
+declare const UsageAggregationError_base: Schema.Class<UsageAggregationError, Schema.TaggedStruct<"UsageAggregationError", {
+  readonly field: Schema.NonEmptyString;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Canonical usage could not be aggregated without exceeding safe-integer accounting. */
+declare class UsageAggregationError extends UsageAggregationError_base {}
+/** Combine disjoint totals, retaining uncertainty and rejecting numeric overflow. */
+declare const sumRunTotals: (contributions: readonly RunTotals[]) => Effect.Effect<RunTotals, UsageAggregationError, never>;
+/** Flatten a canonical settlement summary without discarding its coverage markers. */
+declare const runTotalsFromSummary: (summary: RunUsageSummary) => RunTotals;
+/**
+ * Deterministically aggregate canonical per-call usage without making cached tokens free.
+ * A validated seed retains earlier call totals and pricing groups without retaining those calls.
+ * Empty contributions do not change completeness; the seed is never mutated.
+ */
+declare const summarizeModelUsage: (calls: readonly ModelCallUsage[], seed?: RunUsageSummary | undefined) => Effect.Effect<RunUsageSummary, UsageAggregationError, never>;
+//#endregion
+export { unknownRunTotals as _, ModelUsageGroup as a, RunUsageReport as c, UsageCompleteness as d, Usage_d_exports as f, summarizeModelUsage as g, sumRunTotals as h, ModelResponseIdentity as i, RunUsageSummary as l, runTotalsFromSummary as m, InputTokenUsage as n, OutputTokenUsage as o, emptyRunTotals as p, ModelCallUsage as r, RunTotals as s, ChildRunUsage as t, UsageAggregationError as u };
+//# sourceMappingURL=Usage-Dx0aknfk.d.mts.map

package/dist/WakeScheduler-EjUF-GhC.d.mts

@@ -0,0 +1,56 @@
+import { u as ThreadId } from "./Identifiers-CN2s30fF.mjs";
+import { Context, Effect, Layer, Scope, Stream } from "effect";
+declare namespace WakeScheduler_d_exports {
+  export { WakeScheduler, WakeSubscriptionHub, makeWakeSubscriptionHub };
+}
+/**
+ * Incarnation-local, thread-keyed wake registrations. A registration is installed before
+ * its returned Effect can be awaited, which lets a caller subscribe, check durable authority,
+ * and then park without a lost-wakeup window.
+ */
+interface WakeSubscriptionHub {
+  /** Register one Scope-owned waiter and return its one-shot wake Effect. */
+  readonly subscribe: (threadId: ThreadId) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;
+  /** Wake every currently registered waiter for exactly this Thread. */
+  readonly notify: (threadId: ThreadId) => Effect.Effect<void>;
+}
+/**
+ * Build the shared per-incarnation registration primitive used by host WakeSchedulers. The hub
+ * contains hints only: eviction may discard it, while a reconnecting caller re-subscribes and
+ * rechecks canonical storage. Scope finalizers remove cancelled waiters, and notify broadcasts
+ * instead of consuming a signal that belongs to another waiter.
+ */
+declare const makeWakeSubscriptionHub: Effect.Effect<WakeSubscriptionHub>;
+declare const WakeScheduler_base: Context.ServiceClass<WakeScheduler, "@effect-agent/thread/WakeScheduler", {
+  /** Best-effort hint that `threadId` may have claimable or settled work. Never fails. */
+  readonly notify: (threadId: ThreadId) => Effect.Effect<void>;
+  /** Scope-owned one-shot registration for exactly one Thread. */
+  readonly subscribe: (threadId: ThreadId) => Effect.Effect<Effect.Effect<void>, never, Scope.Scope>;
+  /** Scope-owned subscription to wake hints, starting at subscription time. */
+  readonly wakes: Stream.Stream<ThreadId>;
+}>;
+/**
+ * Liveness hint channel for durable schedulers. `notify` announces that a Thread lane may
+ * have claimable, canonical, or settled work; `wakes` is the all-lanes subscription surface for
+ * workers, while `subscribe` installs an efficient one-Thread wait registration.
+ *
+ * Correctness must NEVER depend on delivery: notifications may be dropped, coalesced, duplicated,
+ * or observed by no subscriber (a notify before any subscription is simply lost). Every consumer
+ * must pair a wake with durable authority: workers use periodic SubmissionLedger scans, while a
+ * public progress waiter subscribes before its canonical read and reconnects/rechecks after an
+ * incarnation loss (persistence §14).
+ *
+ * Each run of `wakes` creates its own subscription whose resources live in that run's Scope and
+ * are released when the consuming stream ends or is interrupted. Implementations must not spawn
+ * daemon fibers.
+ */
+declare class WakeScheduler extends WakeScheduler_base {
+  /**
+   * Discards every notification and never wakes anyone. Valid because WakeScheduler is only a
+   * liveness hint: consumers relying on ledger scans stay correct, merely slower.
+   */
+  static readonly layerNoop: Layer.Layer<WakeScheduler>;
+}
+//#endregion
+export { makeWakeSubscriptionHub as i, WakeScheduler_d_exports as n, WakeSubscriptionHub as r, WakeScheduler as t };
+//# sourceMappingURL=WakeScheduler-EjUF-GhC.d.mts.map

package/dist/Worker-Du9dhVnp.d.mts

@@ -0,0 +1,279 @@
+import { l as SubagentGrant, p as WorkerOperationTool, s as SubagentExecutionFailure } from "./SubagentContract-DdT7Cqe6.mjs";
+import { a as Receipt } from "./Receipt-BAHyigAF.mjs";
+import { r as Update } from "./AgentUpdates-DMJ-_xow.mjs";
+import { a as FailureDiagnostic_d_exports, r as Diagnostic } from "./FailureDiagnostic-CaAkzGHL.mjs";
+import { t as AgentPolicy } from "./AgentPolicy-BqDoSXO6.mjs";
+import { Schema } from "effect";
+declare namespace Worker_d_exports {
+  export { FrameworkMessage, WorkerBudgetScope, WorkerCompletion, WorkerContext, WorkerError, WorkerHistoryEntry, WorkerOperationTool, WorkerPage, WorkerRef, WorkerReport, WorkerSource, WorkerStarted, WorkerSummary, WorkerUpdate };
+}
+/** A reusable child Thread, correlated with its declaration. This value grants no authority. */
+declare const WorkerRef: Schema.Struct<{
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+  readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>;
+type WorkerRef = typeof WorkerRef.Type;
+/** A continuing worker identity and retained first delivery, never an execution handle. */
+declare const WorkerStarted: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly delivery: Schema.Union<readonly [Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"pending">;
+    readonly receipt: Schema.Null;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"accepted">;
+    readonly receipt: typeof Receipt;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NullOr<Schema.NonEmptyString>;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"processed">;
+    readonly receipt: typeof Receipt;
+    readonly settlement: Schema.Struct<{
+      readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+      readonly outcome: Schema.Literals<readonly ["completed", "failed", "aborted"]>;
+    }>;
+    readonly reason: Schema.Null;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"refused">;
+    readonly receipt: Schema.Null;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NonEmptyString;
+  }>, Schema.Struct<{
+    readonly message: Schema.Struct<{
+      readonly ownerThreadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+      readonly messageId: Schema.brand<Schema.NonEmptyString, "@effect-agent/thread/IdempotencyKey">;
+    }>;
+    readonly status: Schema.Literal<"parked">;
+    readonly receipt: Schema.NullOr<typeof Receipt>;
+    readonly settlement: Schema.Null;
+    readonly reason: Schema.NonEmptyString;
+  }>]>;
+}>;
+type WorkerStarted = typeof WorkerStarted.Type;
+/** A host-authorized Run allowance is independent of the immutable delegation lineage. */
+declare const WorkerBudgetScope: Schema.Literals<readonly ["source-subtree", "worker-run"]>;
+type WorkerBudgetScope = typeof WorkerBudgetScope.Type;
+/** Host-bound caller metadata. Programmatic calls never fabricate Run or Tool Call identities. */
+declare const WorkerSource: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"tool">;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"programmatic">;
+  readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+}>]>;
+type WorkerSource = typeof WorkerSource.Type;
+/** The caller's effective policy and root-relative depth, resolved by its host. */
+declare const WorkerContext: Schema.Struct<{
+  readonly source: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"tool">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly toolCallId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"programmatic">;
+    readonly agentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>]>;
+  readonly policy: typeof AgentPolicy;
+  readonly depth: Schema.Natural;
+  readonly grant: Schema.optionalKey<typeof SubagentGrant>;
+}>;
+type WorkerContext = typeof WorkerContext.Type;
+/** Bounded durable listing data; a latest Receipt never substitutes for a requested Receipt. */
+declare const WorkerSummary: Schema.Struct<{
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly latestReceipt: Schema.NullOr<typeof Receipt>;
+  readonly state: Schema.Literals<readonly ["starting", "active", "idle"]>;
+}>;
+type WorkerSummary = typeof WorkerSummary.Type;
+declare const WorkerPage: Schema.Struct<{
+  readonly items: Schema.$Array<Schema.Struct<{
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly latestReceipt: Schema.NullOr<typeof Receipt>;
+    readonly state: Schema.Literals<readonly ["starting", "active", "idle"]>;
+  }>>;
+  readonly next: Schema.NullOr<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">>;
+}>;
+type WorkerPage = typeof WorkerPage.Type;
+/** Authorized canonical history, encoded independently of storage-adapter representations. */
+declare const WorkerHistoryEntry: Schema.Struct<{
+  readonly sequence: Schema.Natural;
+  readonly recordId: Schema.NonEmptyString;
+  readonly record: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+type WorkerHistoryEntry = typeof WorkerHistoryEntry.Type;
+declare const WorkerError_base: Schema.Class<WorkerError, Schema.TaggedStruct<"WorkerError", {
+  readonly cause: Schema.optionalKey<Schema.decodeTo<Schema.Unknown, Schema.Codec<Diagnostic, Diagnostic, never, never>, never, never>>;
+  readonly stack: Schema.optionalKey<Schema.String>;
+  /** Concurrency pressure may clear without changing the request. */
+  readonly retryable: Schema.optionalKey<Schema.Literal<true>>;
+  readonly operation: Schema.Literals<readonly ["context", "start", "followUp", "inspect", "observe", "await", "list", "cancel"]>;
+  readonly reason: Schema.Literals<readonly ["denied", "declaration-unavailable", "worker-mismatch", "receipt-mismatch", "message-mismatch", "idempotency-conflict", "capacity", "not-found", "delivery-pending", "storage", "corrupt", "unavailable"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Closed host-boundary failures. Original causes stay private and survive diagnostic transport.
+ * Retained delivery states are successful MessageStatus values, including pending and refused.
+ * After a storage failure, keep the same idempotency key and parameters when reconciling.
+ */
+declare class WorkerError extends WorkerError_base {}
+/** One projected canonical Run outcome. Joined receipts share this identity. */
+declare const WorkerReport: <Success extends Schema.Top>(success: Success) => Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"Settled">;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly receipt: typeof Receipt;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literal<"completed">;
+  readonly result: Schema.Union<readonly [Success]>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"Settled">;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly receipt: typeof Receipt;
+  readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+  readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+  readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+  readonly failure: typeof SubagentExecutionFailure;
+}>]>;
+type WorkerReport<Success extends Schema.Top> = ReturnType<typeof WorkerReport<Success>>["Type"];
+/** Framework message stored separately from the parent's application input. */
+declare const WorkerCompletion: Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerCompletion">;
+  readonly budgetExhausted: Schema.Boolean;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly report: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literal<"completed">;
+    readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+    readonly failure: typeof SubagentExecutionFailure;
+  }>]>;
+}>;
+type WorkerCompletion = typeof WorkerCompletion.Type;
+/** Source-worker intermediate output, kept separate from application input. */
+declare const WorkerUpdate: Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerUpdate">;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly update: typeof Update;
+}>;
+type WorkerUpdate = typeof WorkerUpdate.Type;
+declare const FrameworkMessage: Schema.Union<readonly [Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerCompletion">;
+  readonly budgetExhausted: Schema.Boolean;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly report: Schema.Union<readonly [Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literal<"completed">;
+    readonly result: Schema.Union<readonly [Schema.Codec<Schema.Json, Schema.Json, never, never>]>;
+  }>, Schema.Struct<{
+    readonly _tag: Schema.Literal<"Settled">;
+    readonly worker: Schema.Struct<{
+      readonly schemaVersion: Schema.Literal<1>;
+      readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+      readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+      readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+    }>;
+    readonly receipt: typeof Receipt;
+    readonly runId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/RunId">;
+    readonly settlementId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/SettlementId">;
+    readonly outcome: Schema.Literals<readonly ["failed", "aborted"]>;
+    readonly failure: typeof SubagentExecutionFailure;
+  }>]>;
+}>, Schema.Struct<{
+  readonly _tag: Schema.Literal<"WorkerUpdate">;
+  readonly schemaVersion: Schema.Literal<1>;
+  readonly worker: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly delegationId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/DelegationId">;
+    readonly targetAgentId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/AgentId">;
+    readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  }>;
+  readonly update: typeof Update;
+}>]>;
+type FrameworkMessage = typeof FrameworkMessage.Type;
+//#endregion
+export { WorkerError as a, WorkerRef as c, WorkerStarted as d, WorkerSummary as f, WorkerContext as i, WorkerReport as l, Worker_d_exports as m, WorkerBudgetScope as n, WorkerHistoryEntry as o, WorkerUpdate as p, WorkerCompletion as r, WorkerPage as s, FrameworkMessage as t, WorkerSource as u };
+//# sourceMappingURL=Worker-Du9dhVnp.d.mts.map