effect-agent 0.1.0-beta.85 → 0.1.0-beta.87

package/dist/ToolResult-DmmgoChv.d.mts

@@ -0,0 +1,61 @@
+import * as Schema from "effect/Schema";
+declare namespace ToolResult_d_exports {
+  export { ToolResultBounds, TruncatedToolResult, UnserializableToolResult, applyToolResultBounds, unserializableToolResult };
+}
+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 { applyToolResultBounds as a, UnserializableToolResult as i, ToolResult_d_exports as n, unserializableToolResult as o, TruncatedToolResult as r, ToolResultBounds as t };
+//# sourceMappingURL=ToolResult-DmmgoChv.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-CaPYykpe.d.mts

@@ -0,0 +1,228 @@
+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 { t as AgentPolicy } from "./AgentPolicy-CetmQrf3.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 worker identity and the Receipt for one accepted input, 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 receipt: typeof Receipt;
+}>;
+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", {
+  /** Pending input or 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", "idempotency-conflict", "capacity", "not-found", "delivery-pending", "storage", "corrupt", "unavailable"]>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Closed host-boundary failures. Infrastructure diagnostics remain in host telemetry.
+ * `delivery-pending` confirms retained input, not destination acceptance or execution.
+ * Keep the same idempotency key and parameters when reconciling; never launch a replacement.
+ */
+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-CaPYykpe.d.mts.map

package/dist/agent-registration-CWDMOAZA.mjs

@@ -0,0 +1,172 @@
+import { AgentId } from "./core/Identifiers.mjs";
+import { a as PinnedTool, l as ToolNamespace, n as DiscoveryTool, r as IncludesCatalogDocumentation, t as AdditionalToolCatalog } from "./ToolExposure-C93U1sPu.mjs";
+import { BackgroundReporting, WorkerReportPreparationFailure } from "./engine/SubagentHost.mjs";
+import { DigestError, digestDefinitions } from "./durable/Digest.mjs";
+import { Tool } from "effect/unstable/ai";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/durable/internal/agent-registration.ts
+/**
+* No Agent Binding is registered for the requested stable identity. Recovery
+* fails closed: it never substitutes the latest Binding or runs different
+* code.
+*/
+var BindingUnavailable = class extends Schema.TaggedError()("BindingUnavailable", {
+	agentId: AgentId,
+	message: Schema.String
+}) {};
+/**
+* A Binding is registered for the identity but its exact stored
+* definition/model/tool digests do not match the claimed head's stored
+* digests byte-for-byte. Fail closed (SUB-023): missing or different code is
+* a typed compatibility failure, never a silent substitution.
+*/
+var BindingDigestMismatch = class extends Schema.TaggedError()("BindingDigestMismatch", {
+	agentId: AgentId,
+	message: Schema.String
+}) {};
+/** Byte-for-byte equality of two stored definition digest triples (SUB-023). */
+const definitionDigestsEqual = (left, right) => left.agent === right.agent && left.model === right.model && left.tools === right.tools;
+const captureReporting = (reports) => Effect.map(Effect.context(), (context) => reports.map((report) => ({
+	...report,
+	prepare: (value) => Effect.scoped(Effect.suspend(() => report.prepare(value))).pipe(Effect.provide(context), Effect.mapError((error) => Schema.is(WorkerReportPreparationFailure)(error) ? error : WorkerReportPreparationFailure.make({ stage: "preparation" })))
+})));
+const backgroundReports = (definition) => [...new Set(Object.values(definition.toolkit.tools).flatMap((tool) => {
+	const report = Context.get(tool.annotations, BackgroundReporting);
+	return report === void 0 ? [] : [report];
+}))];
+const capture = (agent, attemptLayer) => Effect.map(Effect.context(), (context) => ({
+	agentId: agent.definition.id,
+	definition: agent.definition,
+	attempt: (driver, threadId, claim) => {
+		const execute = driver(agent, threadId, claim);
+		return (attemptLayer === void 0 ? execute : execute.pipe(Effect.provide(Layer.fresh(attemptLayer({
+			threadId,
+			submissionId: claim.submissionId,
+			attemptId: claim.attemptId
+		}))))).pipe(Effect.provide(context));
+	}
+}));
+/**
+* Build one exact worker registration from an executable Agent Binding and
+* its already-computed definition digests.
+*
+* `make(agent, digests)` captures the binding plus its worker-requirement
+* Context at Layer/effect construction time. Hosts that start from application
+* version declarations should use `compileRegistrations`; low-level fixtures
+* may supply a previously computed digest triple directly.
+*/
+const DurableWorkerBinding = { make: (agent, digests, reporting) => Effect.gen(function* () {
+	const binding = yield* capture(agent);
+	const reports = yield* captureReporting([...reporting ?? [], ...backgroundReports(agent.definition)]);
+	return {
+		...binding,
+		digests,
+		reporting: reports
+	};
+}) };
+/** INTERNAL identity-only capture retained for the legacy direct worker path. */
+const makeLegacyWorkerBinding = capture;
+const resolveWorkerBinding = (bindings, agentId, digests) => {
+	const registered = bindings.filter((binding) => binding.agentId === agentId);
+	if (registered.length === 0) return Effect.fail(BindingUnavailable.make({
+		agentId,
+		message: `No Agent Binding is registered for ${agentId}; recovery never substitutes different code (SUB-023)`
+	}));
+	const exact = registered.find((binding) => definitionDigestsEqual(binding.digests, digests));
+	if (exact === void 0) return Effect.fail(BindingDigestMismatch.make({
+		agentId,
+		message: `The registered Binding for ${agentId} does not match the stored definition digests exactly; missing or different code fails closed (SUB-023)`
+	}));
+	return Effect.succeed(exact);
+};
+/** Resolve authoring-time admission through the one exact host registration, never by identity alone. */
+const resolveDefinitionBinding = (bindings, definition) => {
+	const candidates = bindings.filter((binding) => binding.agentId === definition.id);
+	const binding = candidates[0];
+	if (candidates.length !== 1 || binding === void 0) return Effect.fail(BindingUnavailable.make({
+		agentId: definition.id,
+		message: "Registered admission requires exactly one binding for the Agent identity"
+	}));
+	if (!Object.is(binding.definition, definition)) return Effect.fail(BindingUnavailable.make({
+		agentId: definition.id,
+		message: "Registered admission requires the exact Agent Definition used in registration"
+	}));
+	return Effect.succeed(binding);
+};
+const registrationDefinitions = (entry) => {
+	const definition = entry.model === void 0 ? entry.agent.definition : entry.agent;
+	const automatic = backgroundReports(definition);
+	const declaredDefinitions = definition.updates === void 0 ? entry.definitions : {
+		...entry.definitions,
+		agent: {
+			declaration: entry.definitions.agent,
+			updates: Schema.decodeUnknownSync(Schema.Json)(Tool.getJsonSchemaFromSchema(definition.updates)),
+			updateProtocol: {
+				schemaVersion: 1,
+				tool: "emit_update"
+			}
+		}
+	};
+	const definitions = automatic.length === 0 ? declaredDefinitions : {
+		...declaredDefinitions,
+		agent: {
+			declaration: declaredDefinitions.agent,
+			backgroundReporting: automatic.map((report) => ({
+				delegationId: report.delegationId,
+				targetAgentId: report.target.id,
+				mode: report.mode ?? "custom",
+				destinationDelegationId: report.destination?.delegationId ?? null
+			}))
+		}
+	};
+	const exposure = definition.toolExposure;
+	if (exposure === void 0 && !Object.values(definition.toolkit.tools).some((tool) => Context.get(tool.annotations, DiscoveryTool) || Context.get(tool.annotations, PinnedTool))) return definitions;
+	return {
+		...definitions,
+		agent: {
+			declaration: definitions.agent,
+			toolExposure: {
+				initialToolNames: exposure === void 0 ? null : [...exposure.initialToolNames ?? []],
+				maxTools: exposure?.maxTools ?? 64,
+				maxSchemaBytes: exposure?.maxSchemaBytes ?? 262144,
+				requiredCompletion: definition.completion?.required === true ? definition.completion.tool : null,
+				tools: Object.values(definition.toolkit.tools).map((tool) => ({
+					name: tool.name,
+					pinned: Context.get(tool.annotations, PinnedTool),
+					discovery: Context.get(tool.annotations, DiscoveryTool),
+					namespace: Context.get(tool.annotations, ToolNamespace) ?? null,
+					includesCatalogDocumentation: Context.get(tool.annotations, IncludesCatalogDocumentation),
+					additional: Context.get(tool.annotations, AdditionalToolCatalog).map((entry) => ({
+						name: entry.tool.name,
+						namespace: entry.namespace,
+						method: entry.method
+					}))
+				}))
+			}
+		}
+	};
+};
+const compileRegistration = (entry) => Effect.flatMap(Effect.try({
+	try: () => registrationDefinitions(entry),
+	catch: () => DigestError.make({ message: "Agent update schema has no serializable wire contract" })
+}).pipe(Effect.flatMap(digestDefinitions)), (digests) => Effect.gen(function* () {
+	const binding = yield* capture(entry.model === void 0 ? entry.agent : {
+		definition: entry.agent,
+		model: entry.model
+	}, entry.attemptLayer);
+	const reporting = yield* captureReporting([...entry.reporting ?? [], ...backgroundReports(binding.definition)]);
+	return {
+		...binding,
+		digests,
+		reporting
+	};
+}));
+/** Compile heterogeneous Agent descriptors into exact, dependency-closed worker registrations. */
+const compileRegistrations = (entries) => {
+	const compileEntry = compileRegistration;
+	return Effect.forEach(entries, compileEntry);
+};
+//#endregion
+export { definitionDigestsEqual as a, resolveWorkerBinding as c, compileRegistrations as i, BindingUnavailable as n, makeLegacyWorkerBinding as o, DurableWorkerBinding as r, resolveDefinitionBinding as s, BindingDigestMismatch as t };
+
+//# sourceMappingURL=agent-registration-CWDMOAZA.mjs.map