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

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-CfwzMZEK.mjs

@@ -0,0 +1,271 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from "./core/Identifiers.mjs";
+import { AgentPolicy } from "./core/AgentPolicy.mjs";
+import { IdempotencyKey, Receipt } from "./core/Receipt.mjs";
+import { Update } from "./core/AgentUpdates.mjs";
+import { o as Value } from "./FailureDiagnostic-BElLOoED.mjs";
+import { SubagentExecutionFailure, SubagentGrant, WorkerOperationTool } from "./core/SubagentContract.mjs";
+import { Schema } from "effect";
+//#region src/core/internal/message-status.ts
+/** A retained outbound delivery identity, not a destination Receipt or access grant. */
+const MessageRef = Schema.Struct({
+	ownerThreadId: ThreadId,
+	messageId: IdempotencyKey
+});
+const Reason = Schema.NonEmptyString.check(Schema.isMaxLength(256));
+const identity = { message: MessageRef };
+/**
+* Source-owned delivery evidence. Pending confirms retention only; accepted supplies the
+* destination Receipt, and processed supplies its canonical settlement. Neither retention nor
+* acceptance proves execution. Refused is a definite rejection; parked stops automatic retry
+* while retaining the same identity and any acceptance evidence. Inspect instead of resending.
+*/
+const MessageStatus = Schema.Union([
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("pending"),
+		receipt: Schema.Null,
+		settlement: Schema.Null,
+		reason: Schema.NullOr(Reason)
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("accepted"),
+		receipt: Receipt,
+		settlement: Schema.Null,
+		reason: Schema.NullOr(Reason)
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("processed"),
+		receipt: Receipt,
+		settlement: Schema.Struct({
+			settlementId: SettlementId,
+			outcome: Schema.Literals([
+				"completed",
+				"failed",
+				"aborted"
+			])
+		}),
+		reason: Schema.Null
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("refused"),
+		receipt: Schema.Null,
+		settlement: Schema.Null,
+		reason: Reason
+	}),
+	Schema.Struct({
+		...identity,
+		status: Schema.Literal("parked"),
+		receipt: Schema.NullOr(Receipt),
+		settlement: Schema.Null,
+		reason: Reason
+	})
+]);
+//#endregion
+//#region src/core/Worker.ts
+var Worker_exports = /* @__PURE__ */ __exportAll({
+	AssignmentDisposition: () => AssignmentDisposition,
+	AssignmentTerminal: () => AssignmentTerminal,
+	FrameworkMessage: () => FrameworkMessage,
+	WorkerAppliedInput: () => WorkerAppliedInput,
+	WorkerBudgetScope: () => WorkerBudgetScope,
+	WorkerCompletion: () => WorkerCompletion,
+	WorkerContext: () => WorkerContext,
+	WorkerError: () => WorkerError,
+	WorkerHistoryEntry: () => WorkerHistoryEntry,
+	WorkerInput: () => WorkerInput,
+	WorkerOperationTool: () => WorkerOperationTool,
+	WorkerPage: () => WorkerPage,
+	WorkerRef: () => WorkerRef,
+	WorkerReport: () => WorkerReport,
+	WorkerRun: () => WorkerRun,
+	WorkerSource: () => WorkerSource,
+	WorkerStarted: () => WorkerStarted,
+	WorkerStop: () => WorkerStop,
+	WorkerStopped: () => WorkerStopped,
+	WorkerSummary: () => WorkerSummary,
+	WorkerUpdate: () => WorkerUpdate
+});
+/** Assignment output selected through the Definition's runDisposition declaration. */
+const AssignmentDisposition = Schema.Literals(["completed", "waiting"]);
+/** A permanent destination outcome; an ordinary Run completion does not imply this. */
+const AssignmentTerminal = Schema.Literals([
+	"completed",
+	"failed",
+	"cancelled"
+]);
+/** A reusable child Thread, correlated with its declaration. This value grants no authority. */
+const WorkerRef = Schema.Struct({
+	schemaVersion: Schema.Literal(1),
+	delegationId: DelegationId,
+	targetAgentId: AgentId,
+	threadId: ThreadId
+});
+/** A continuing worker identity and retained first delivery, never an execution handle. */
+const WorkerStarted = Schema.Struct({
+	worker: WorkerRef,
+	delivery: MessageStatus
+}).check(Schema.makeFilter(({ worker, delivery }) => delivery.receipt === null || worker.threadId === delivery.receipt.threadId));
+/** Stable owner command. Reusing its key for a different worker conflicts. */
+const WorkerStop = Schema.Struct({
+	worker: WorkerRef,
+	idempotencyKey: IdempotencyKey
+});
+/** The inbox is sealed and active execution has released ownership. External actions are not undone. */
+const WorkerStopped = WorkerStop;
+/** A host-authorized Run allowance is independent of the immutable delegation lineage. */
+const WorkerBudgetScope = Schema.Literals(["source-subtree", "worker-run"]);
+/** Host-bound caller metadata. Programmatic calls never fabricate Run or Tool Call identities. */
+const WorkerSource = Schema.Union([Schema.Struct({
+	_tag: Schema.Literal("tool"),
+	agentId: AgentId,
+	threadId: ThreadId,
+	runId: RunId,
+	toolCallId: ToolCallId
+}), Schema.Struct({
+	_tag: Schema.Literal("programmatic"),
+	agentId: AgentId,
+	threadId: ThreadId
+})]);
+/** The caller's effective policy and root-relative depth, resolved by its host. */
+const WorkerContext = Schema.Struct({
+	source: WorkerSource,
+	policy: AgentPolicy,
+	depth: Schema.Natural,
+	grant: Schema.optionalKey(SubagentGrant)
+});
+/** Admission identity is distinct from canonical input application. */
+const WorkerInput = Schema.Struct({
+	receipt: Receipt,
+	messageId: IdempotencyKey
+});
+const WorkerAppliedInput = Schema.Struct({
+	...WorkerInput.fields,
+	runId: RunId,
+	sequence: Schema.Natural
+});
+/** A Run outcome is not assignment completion. Interpret only a Definition's disposition. */
+const WorkerRun = Schema.Struct({
+	runId: RunId,
+	hostReceipt: Receipt,
+	outcome: Schema.NullOr(Schema.Literals([
+		"completed",
+		"failed",
+		"aborted"
+	])),
+	disposition: Schema.NullOr(Schema.Json)
+});
+/** Bounded durable listing data; a latest Receipt never substitutes for a requested Receipt. */
+const WorkerSummary = Schema.Struct({
+	worker: WorkerRef,
+	latestReceipt: Schema.NullOr(Receipt),
+	/** stopping/stopped identify an owner-issued worker stop, never an ordinary Receipt abort. */
+	state: Schema.Literals([
+		"starting",
+		"active",
+		"idle",
+		"stopping",
+		"stopped",
+		"completed",
+		"failed",
+		"cancelled"
+	]),
+	acceptedInput: Schema.NullOr(WorkerInput),
+	appliedInput: Schema.NullOr(WorkerAppliedInput),
+	run: Schema.NullOr(WorkerRun),
+	/** One retained unadmitted input, if any; its state is independent of destination execution. */
+	pendingDelivery: Schema.NullOr(MessageStatus),
+	/** Consistent destination facts; pending delivery has its own source-owned version. */
+	watermark: Schema.Struct({
+		canonicalSequence: Schema.Natural,
+		acceptedQueueSequence: Schema.Natural,
+		pendingDeliveryVersion: Schema.NullOr(Schema.Natural)
+	})
+});
+const WorkerPage = Schema.Struct({
+	items: Schema.Array(WorkerSummary).check(Schema.isMaxLength(100)),
+	next: Schema.NullOr(ThreadId)
+});
+/** Authorized canonical history, encoded independently of storage-adapter representations. */
+const WorkerHistoryEntry = Schema.Struct({
+	sequence: Schema.Natural.check(Schema.isGreaterThan(0)),
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(1024)),
+	record: Schema.Json
+});
+/**
+* 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.
+*/
+var WorkerError = class extends Schema.TaggedError()("WorkerError", {
+	cause: Schema.optionalKey(Value),
+	stack: Schema.optionalKey(Schema.String),
+	/** Concurrency pressure may clear without changing the request. */
+	retryable: Schema.optionalKey(Schema.Literal(true)),
+	operation: Schema.Literals([
+		"context",
+		"start",
+		"followUp",
+		"inspect",
+		"observe",
+		"await",
+		"list",
+		"cancel",
+		"stop"
+	]),
+	reason: Schema.Literals([
+		"denied",
+		"declaration-unavailable",
+		"worker-mismatch",
+		"receipt-mismatch",
+		"message-mismatch",
+		"idempotency-conflict",
+		"capacity",
+		"not-found",
+		"delivery-pending",
+		"storage",
+		"corrupt",
+		"unavailable"
+	])
+}) {};
+/** One projected canonical Run outcome. Joined receipts share this identity. */
+const WorkerReport = (success) => {
+	const identity = {
+		_tag: Schema.Literal("Settled"),
+		worker: WorkerRef,
+		receipt: Receipt,
+		runId: RunId,
+		settlementId: SettlementId
+	};
+	return Schema.Union([Schema.Struct({
+		...identity,
+		outcome: Schema.Literal("completed"),
+		result: Schema.Union([success])
+	}), Schema.Struct({
+		...identity,
+		outcome: Schema.Literals(["failed", "aborted"]),
+		failure: SubagentExecutionFailure
+	})]);
+};
+/** Framework message stored separately from the parent's application input. */
+const WorkerCompletion = Schema.Struct({
+	_tag: Schema.Literal("WorkerCompletion"),
+	budgetExhausted: Schema.Boolean,
+	schemaVersion: Schema.Literal(1),
+	report: WorkerReport(Schema.Json)
+}).check(Schema.makeFilter(({ report }) => report.worker.threadId === report.receipt.threadId));
+/** Source-worker intermediate output, kept separate from application input. */
+const WorkerUpdate = Schema.Struct({
+	_tag: Schema.Literal("WorkerUpdate"),
+	schemaVersion: Schema.Literal(1),
+	worker: WorkerRef,
+	update: Update
+}).check(Schema.makeFilter(({ worker, update }) => worker.threadId === update.threadId && worker.targetAgentId === update.agentId));
+const FrameworkMessage = Schema.Union([WorkerCompletion, WorkerUpdate]);
+//#endregion
+export { MessageStatus as C, MessageRef as S, WorkerStop as _, WorkerBudgetScope as a, WorkerUpdate as b, WorkerError as c, WorkerPage as d, WorkerRef as f, WorkerStarted as g, WorkerSource as h, WorkerAppliedInput as i, WorkerHistoryEntry as l, WorkerRun as m, AssignmentTerminal as n, WorkerCompletion as o, WorkerReport as p, FrameworkMessage as r, WorkerContext as s, AssignmentDisposition as t, WorkerInput as u, WorkerStopped as v, Worker_exports as x, WorkerSummary as y };
+
+//# sourceMappingURL=Worker-CfwzMZEK.mjs.map

package/dist/Worker-CfwzMZEK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Worker-CfwzMZEK.mjs","names":["FailureDiagnostic.Value"],"sources":["../src/core/internal/message-status.ts","../src/core/Worker.ts"],"sourcesContent":["import { Schema } from \"effect\";\n\nimport { SettlementId, ThreadId } from \"../Identifiers.ts\";\nimport { IdempotencyKey, Receipt } from \"../Receipt.ts\";\n\n/** A retained outbound delivery identity, not a destination Receipt or access grant. */\nexport const MessageRef = Schema.Struct({ ownerThreadId: ThreadId, messageId: IdempotencyKey });\nexport type MessageRef = typeof MessageRef.Type;\n\nconst Reason = Schema.NonEmptyString.check(Schema.isMaxLength(256));\nconst identity = { message: MessageRef };\n\n/**\n * Source-owned delivery evidence. Pending confirms retention only; accepted supplies the\n * destination Receipt, and processed supplies its canonical settlement. Neither retention nor\n * acceptance proves execution. Refused is a definite rejection; parked stops automatic retry\n * while retaining the same identity and any acceptance evidence. Inspect instead of resending.\n */\nexport const MessageStatus = Schema.Union([\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"pending\"),\n    receipt: Schema.Null,\n    settlement: Schema.Null,\n    reason: Schema.NullOr(Reason),\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"accepted\"),\n    receipt: Receipt,\n    settlement: Schema.Null,\n    reason: Schema.NullOr(Reason),\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"processed\"),\n    receipt: Receipt,\n    settlement: Schema.Struct({\n      settlementId: SettlementId,\n      outcome: Schema.Literals([\"completed\", \"failed\", \"aborted\"]),\n    }),\n    reason: Schema.Null,\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"refused\"),\n    receipt: Schema.Null,\n    settlement: Schema.Null,\n    reason: Reason,\n  }),\n  Schema.Struct({\n    ...identity,\n    status: Schema.Literal(\"parked\"),\n    receipt: Schema.NullOr(Receipt),\n    settlement: Schema.Null,\n    reason: Reason,\n  }),\n]);\n\nexport type MessageStatus = typeof MessageStatus.Type;\n","import { Schema } from \"effect\";\n\nimport { AgentPolicy } from \"./AgentPolicy.ts\";\nimport { Update } from \"./AgentUpdates.ts\";\nimport * as FailureDiagnostic from \"./FailureDiagnostic.ts\";\nimport { AgentId, DelegationId, RunId, SettlementId, ThreadId, ToolCallId } from \"./Identifiers.ts\";\nimport { MessageStatus } from \"./internal/message-status.ts\";\nimport { IdempotencyKey, Receipt } from \"./Receipt.ts\";\nimport { SubagentExecutionFailure, SubagentGrant } from \"./SubagentContract.ts\";\n\n/** Assignment output selected through the Definition's runDisposition declaration. */\nexport const AssignmentDisposition = Schema.Literals([\"completed\", \"waiting\"]);\nexport type AssignmentDisposition = typeof AssignmentDisposition.Type;\n\n/** A permanent destination outcome; an ordinary Run completion does not imply this. */\nexport const AssignmentTerminal = Schema.Literals([\"completed\", \"failed\", \"cancelled\"]);\nexport type AssignmentTerminal = typeof AssignmentTerminal.Type;\n\n/** A reusable child Thread, correlated with its declaration. This value grants no authority. */\nexport const WorkerRef = Schema.Struct({\n  schemaVersion: Schema.Literal(1),\n  delegationId: DelegationId,\n  targetAgentId: AgentId,\n  threadId: ThreadId,\n});\n\nexport type WorkerRef = typeof WorkerRef.Type;\n\n/** A continuing worker identity and retained first delivery, never an execution handle. */\nexport const WorkerStarted = Schema.Struct({\n  worker: WorkerRef,\n  delivery: MessageStatus,\n}).check(\n  Schema.makeFilter(\n    ({ worker, delivery }) =>\n      delivery.receipt === null || worker.threadId === delivery.receipt.threadId,\n  ),\n);\n\nexport type WorkerStarted = typeof WorkerStarted.Type;\n\n/** Stable owner command. Reusing its key for a different worker conflicts. */\nexport const WorkerStop = Schema.Struct({ worker: WorkerRef, idempotencyKey: IdempotencyKey });\nexport type WorkerStop = typeof WorkerStop.Type;\n\n/** The inbox is sealed and active execution has released ownership. External actions are not undone. */\nexport const WorkerStopped = WorkerStop;\nexport type WorkerStopped = typeof WorkerStopped.Type;\n\n/** A host-authorized Run allowance is independent of the immutable delegation lineage. */\nexport const WorkerBudgetScope = Schema.Literals([\"source-subtree\", \"worker-run\"]);\nexport type WorkerBudgetScope = typeof WorkerBudgetScope.Type;\n\n/** Host-bound caller metadata. Programmatic calls never fabricate Run or Tool Call identities. */\nexport const WorkerSource = Schema.Union([\n  Schema.Struct({\n    _tag: Schema.Literal(\"tool\"),\n    agentId: AgentId,\n    threadId: ThreadId,\n    runId: RunId,\n    toolCallId: ToolCallId,\n  }),\n  Schema.Struct({\n    _tag: Schema.Literal(\"programmatic\"),\n    agentId: AgentId,\n    threadId: ThreadId,\n  }),\n]);\n\nexport type WorkerSource = typeof WorkerSource.Type;\n\n/** The caller's effective policy and root-relative depth, resolved by its host. */\nexport const WorkerContext = Schema.Struct({\n  source: WorkerSource,\n  policy: AgentPolicy,\n  depth: Schema.Natural,\n  grant: Schema.optionalKey(SubagentGrant),\n});\n\nexport type WorkerContext = typeof WorkerContext.Type;\n\n/** Admission identity is distinct from canonical input application. */\nexport const WorkerInput = Schema.Struct({ receipt: Receipt, messageId: IdempotencyKey });\nexport type WorkerInput = typeof WorkerInput.Type;\n\nexport const WorkerAppliedInput = Schema.Struct({\n  ...WorkerInput.fields,\n  runId: RunId,\n  sequence: Schema.Natural,\n});\n\n/** A Run outcome is not assignment completion. Interpret only a Definition's disposition. */\nexport const WorkerRun = Schema.Struct({\n  runId: RunId,\n  hostReceipt: Receipt,\n  outcome: Schema.NullOr(Schema.Literals([\"completed\", \"failed\", \"aborted\"])),\n  disposition: Schema.NullOr(Schema.Json),\n});\n\n/** Bounded durable listing data; a latest Receipt never substitutes for a requested Receipt. */\nexport const WorkerSummary = Schema.Struct({\n  worker: WorkerRef,\n  latestReceipt: Schema.NullOr(Receipt),\n  /** stopping/stopped identify an owner-issued worker stop, never an ordinary Receipt abort. */\n  state: Schema.Literals([\n    \"starting\",\n    \"active\",\n    \"idle\",\n    \"stopping\",\n    \"stopped\",\n    \"completed\",\n    \"failed\",\n    \"cancelled\",\n  ]),\n  acceptedInput: Schema.NullOr(WorkerInput),\n  appliedInput: Schema.NullOr(WorkerAppliedInput),\n  run: Schema.NullOr(WorkerRun),\n  /** One retained unadmitted input, if any; its state is independent of destination execution. */\n  pendingDelivery: Schema.NullOr(MessageStatus),\n  /** Consistent destination facts; pending delivery has its own source-owned version. */\n  watermark: Schema.Struct({\n    canonicalSequence: Schema.Natural,\n    acceptedQueueSequence: Schema.Natural,\n    pendingDeliveryVersion: Schema.NullOr(Schema.Natural),\n  }),\n});\n\nexport type WorkerSummary = typeof WorkerSummary.Type;\n\nexport const WorkerPage = Schema.Struct({\n  items: Schema.Array(WorkerSummary).check(Schema.isMaxLength(100)),\n  next: Schema.NullOr(ThreadId),\n});\n\nexport type WorkerPage = typeof WorkerPage.Type;\n\n/** Authorized canonical history, encoded independently of storage-adapter representations. */\nexport const WorkerHistoryEntry = Schema.Struct({\n  sequence: Schema.Natural.check(Schema.isGreaterThan(0)),\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(1_024)),\n  record: Schema.Json,\n});\n\nexport type WorkerHistoryEntry = typeof WorkerHistoryEntry.Type;\n\n/**\n * Closed host-boundary failures. Original causes stay private and survive diagnostic transport.\n * Retained delivery states are successful MessageStatus values, including pending and refused.\n * After a storage failure, keep the same idempotency key and parameters when reconciling.\n */\nexport class WorkerError extends Schema.TaggedError<WorkerError>()(\"WorkerError\", {\n  cause: Schema.optionalKey(FailureDiagnostic.Value),\n  stack: Schema.optionalKey(Schema.String),\n  /** Concurrency pressure may clear without changing the request. */\n  retryable: Schema.optionalKey(Schema.Literal(true)),\n  operation: Schema.Literals([\n    \"context\",\n    \"start\",\n    \"followUp\",\n    \"inspect\",\n    \"observe\",\n    \"await\",\n    \"list\",\n    \"cancel\",\n    \"stop\",\n  ]),\n  reason: Schema.Literals([\n    \"denied\",\n    \"declaration-unavailable\",\n    \"worker-mismatch\",\n    \"receipt-mismatch\",\n    \"message-mismatch\",\n    \"idempotency-conflict\",\n    \"capacity\",\n    \"not-found\",\n    // Decode earlier failures without emitting them for retained deliveries.\n    \"delivery-pending\",\n    \"storage\",\n    \"corrupt\",\n    \"unavailable\",\n  ]),\n}) {}\n\nexport { WorkerOperationTool } from \"./SubagentContract.ts\";\n\n/** One projected canonical Run outcome. Joined receipts share this identity. */\nexport const WorkerReport = <Success extends Schema.Top>(success: Success) => {\n  const identity = {\n    _tag: Schema.Literal(\"Settled\"),\n    worker: WorkerRef,\n    receipt: Receipt,\n    runId: RunId,\n    settlementId: SettlementId,\n  };\n\n  return Schema.Union([\n    // Union preserves the Success codec while making the result field required.\n    Schema.Struct({\n      ...identity,\n      outcome: Schema.Literal(\"completed\"),\n      result: Schema.Union([success]),\n    }),\n    Schema.Struct({\n      ...identity,\n      outcome: Schema.Literals([\"failed\", \"aborted\"]),\n      failure: SubagentExecutionFailure,\n    }),\n  ]);\n};\n\nexport type WorkerReport<Success extends Schema.Top> = ReturnType<\n  typeof WorkerReport<Success>\n>[\"Type\"];\n\n/** Framework message stored separately from the parent's application input. */\nexport const WorkerCompletion = Schema.Struct({\n  _tag: Schema.Literal(\"WorkerCompletion\"),\n  budgetExhausted: Schema.Boolean,\n  schemaVersion: Schema.Literal(1),\n  report: WorkerReport(Schema.Json),\n}).check(Schema.makeFilter(({ report }) => report.worker.threadId === report.receipt.threadId));\n\nexport type WorkerCompletion = typeof WorkerCompletion.Type;\n\n/** Source-worker intermediate output, kept separate from application input. */\nexport const WorkerUpdate = Schema.Struct({\n  _tag: Schema.Literal(\"WorkerUpdate\"),\n  schemaVersion: Schema.Literal(1),\n  worker: WorkerRef,\n  update: Update,\n}).check(\n  Schema.makeFilter(\n    ({ worker, update }) =>\n      worker.threadId === update.threadId && worker.targetAgentId === update.agentId,\n  ),\n);\n\nexport type WorkerUpdate = typeof WorkerUpdate.Type;\nexport const FrameworkMessage = Schema.Union([WorkerCompletion, WorkerUpdate]);\nexport type FrameworkMessage = typeof FrameworkMessage.Type;\n"],"mappings":"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"}