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

package/dist/DurableFailpoint-mx3-nsxU.d.mts

@@ -0,0 +1,41 @@
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace DurableFailpoint_d_exports {
+  export { DurableRuntimeFailpoint, DurableRuntimeFailpointError, DurableRuntimeFailpointHandler, DurableRuntimeFailpointLocation };
+}
+/**
+ * Coordinator-owned failpoint locations (plan §Failpoints). Locations normally sit immediately
+ * AFTER one durable mutation of the six-step coordinator flow, so a fault injected there
+ * simulates a crash between two durable steps; the matching BEFORE boundary of each mutation is
+ * owned by the storage adapters (`ledger:*:before`, `append:before`, ...), giving every durable
+ * mutation a failpoint on both sides (change discipline). Run-start append also exposes its
+ * BEFORE boundary here to distinguish a fresh clock from a committed clock in crash tests.
+ *
+ * The `subagent:*` family covers every durable mutation of the S2 establishment/join protocol
+ * including reservation, request append, child admission, child readiness,
+ * start-link append, sibling per-call settles at the suspension seam, the `waitingForChild`
+ * suspension, child abort propagation, the atomic join batch, and both reservation-release
+ * transitions.
+ */
+declare const DurableRuntimeFailpointLocation: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "run:before-duration-append", "run:after-duration-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "tools:before-unavailable-append", "tools:after-unavailable-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
+type DurableRuntimeFailpointLocation = typeof DurableRuntimeFailpointLocation.Type;
+declare const DurableRuntimeFailpointError_base: Schema.Class<DurableRuntimeFailpointError, Schema.TaggedStruct<"DurableRuntimeFailpointError", {
+  readonly location: Schema.Literals<readonly ["submit:after-admit", "submit:after-materialize", "claim:after-claim", "input:after-canonical-append", "run:before-start-append", "run:after-start-append", "run:before-duration-append", "run:after-duration-append", "turn:after-canonical-append", "turn:after-response-append", "turn:after-results-append", "compaction:before-canonical-append", "compaction:after-canonical-append", "checkpoint:before-save", "checkpoint:after-save", "tools:after-prepared-append", "tools:before-prepared-append", "tools:before-unavailable-append", "tools:after-unavailable-append", "policy:before-reservation-append", "policy:after-reservation-append", "step:after-step-append", "approval:after-request-append", "approval:after-suspend", "join:after-claim", "join:after-canonical-append", "resolve:after-intent", "terminalize:after-reserve", "terminalize:after-canonical-append", "abort:after-intent", "subagent:after-reserve", "subagent:after-request-append", "subagent:after-admit", "subagent:after-child-ready", "subagent:after-start-append", "subagent:after-sibling-settle", "subagent:after-suspend", "subagent:after-child-abort-intent", "subagent:before-join-append", "subagent:after-join-append", "subagent:after-release-pending", "subagent:after-release", "worker:before-source-append", "worker:after-source-append", "worker:before-origin-append", "worker:after-origin-append", "worker:before-completion-append", "worker:after-completion-append", "worker:before-subtree-append", "worker:after-subtree-append", "worker:before-report-append", "worker:after-report-append", "worker:before-report-delivery", "worker:after-report-delivery", "update:before-canonical-append", "update:after-canonical-append", "update:before-delivery-insert", "update:after-delivery-insert"]>;
+}>, import("effect/Cause").YieldableError>;
+/** Injected coordinator fault. Reaching the caller means the preceding durable step committed. */
+declare class DurableRuntimeFailpointError extends DurableRuntimeFailpointError_base {}
+type DurableRuntimeFailpointHandler = (location: DurableRuntimeFailpointLocation) => Effect.Effect<void, DurableRuntimeFailpointError>;
+declare const DurableRuntimeFailpoint_base: Context.ServiceClass<DurableRuntimeFailpoint, "@effect-agent/thread/DurableRuntimeFailpoint", {
+  readonly hit: DurableRuntimeFailpointHandler;
+}>;
+/**
+ * Explicit fault-injection authority used at durable coordinator step boundaries. The process
+ * crash harness (WP5) maps a hit to `process.exit`; in-process tests fail the step with the
+ * typed `DurableRuntimeFailpointError` instead.
+ */
+declare class DurableRuntimeFailpoint extends DurableRuntimeFailpoint_base {
+  /** Production default: no fault injection. */
+  static readonly layer: Layer.Layer<DurableRuntimeFailpoint, never, never>;
+}
+//#endregion
+export { DurableRuntimeFailpointLocation as a, DurableRuntimeFailpointHandler as i, DurableRuntimeFailpoint as n, DurableRuntimeFailpointError as r, DurableFailpoint_d_exports as t };
+//# sourceMappingURL=DurableFailpoint-mx3-nsxU.d.mts.map

package/dist/DurableStep-Cry_iol4.d.mts

@@ -0,0 +1,103 @@
+import { d as ToolCallId } from "./Identifiers-CN2s30fF.mjs";
+import { Tool } from "effect/unstable/ai";
+import { Context, Effect, Option, Schema } from "effect";
+declare namespace DurableStep_d_exports {
+  export { DurableStep, DurableStepError, DurableStepService, PersistedStepResult, RunStepHook, RunStepKey, ToolExecutionClass, ToolExecutionClassValue, getToolExecutionClass };
+}
+/**
+ * Declared external execution class of one Tool, used by the durable runtime
+ * to decide which Tool Calls need the prepared/settled uncertainty protocol:
+ *
+ * - `"readonly"`: the handler performs no external mutation. A crash between
+ *   start and settlement is a free re-run; no prepared record is written.
+ * - `"idempotent"`: the handler declares an external idempotency contract
+ *   (it owns key derivation). Prepared/settled records are written and
+ *   recovery may re-execute without reconciliation proof.
+ * - `"uncertain"`: no external contract is declared. Prepared/settled records
+ *   are written and recovery must reconcile or record an Unknown Outcome.
+ */
+type ToolExecutionClassValue = "readonly" | "idempotent" | "uncertain";
+/**
+ * Effect AI Tool annotation key declaring a Tool's execution class, applied
+ * with `Tool.annotate(ToolExecutionClass, "...")`.
+ *
+ * Unannotated Tools default to `"uncertain"`: security and durability
+ * decisions are fail-closed, so the framework never infers a safer class
+ * from a Tool's shape.
+ */
+declare const ToolExecutionClass: Context.Reference<ToolExecutionClassValue>;
+/** Read a Tool's declared execution class, falling back to the fail-closed `"uncertain"` default. */
+declare const getToolExecutionClass: (tool: Tool.Any) => ToolExecutionClassValue;
+/** Stable identity of one Step within one Tool Call: `(toolCallId, stepName)`. */
+interface RunStepKey {
+  readonly toolCallId: ToolCallId;
+  readonly stepName: string;
+}
+/** A previously committed Step result in its canonical encoded form. */
+interface PersistedStepResult {
+  readonly encodedOutput: unknown;
+}
+/**
+ * Dependency-neutral Step persistence seam implemented by a durable
+ * coordinator and consumed by the engine-provided `DurableStep` service.
+ *
+ * `lookup` returns the committed result for a Step identity when one exists;
+ * `commit` durably records one successful encoded output. Only success is
+ * ever committed — recording failures would replay a transient failure
+ * forever. Both operations are keyed by the deterministic `RunStepKey`, so
+ * replays and racing writers dedupe on record identity in the adapter.
+ */
+interface RunStepHook<Error = never, Requirements = never> {
+  readonly lookup: (key: RunStepKey) => Effect.Effect<Option.Option<PersistedStepResult>, Error, Requirements>;
+  readonly commit: (key: RunStepKey, encodedOutput: unknown) => Effect.Effect<void, Error, Requirements>;
+}
+declare const DurableStepError_base: Schema.Class<DurableStepError, Schema.TaggedStruct<"DurableStepError", {
+  readonly stepName: Schema.String;
+  readonly reason: Schema.Literals<readonly ["duplicate-step-name", "lookup-failed", "recorded-result-invalid", "output-encoding-failed", "commit-failed", "no-active-tool-call"]>;
+  readonly message: Schema.String;
+  readonly toolCallId: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ToolCallId">>;
+  /** Diagnostic cause for the live Effect only; Run events retain the fixed public message. */
+  readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Typed failure of one `DurableStep.do` call.
+ *
+ * `duplicate-step-name` is an identity conflict: Step names must be
+ * deterministic and unique within one Tool Call, and reuse would silently
+ * replay another Step's recorded result. `recorded-result-invalid` is the
+ * replay-with-different-content conflict: a committed result that no longer
+ * decodes through the declared output Schema is never silently accepted.
+ */
+declare class DurableStepError extends DurableStepError_base {}
+/**
+ * Service value provided locally by the engine to each Tool Call's handler.
+ *
+ * `do` runs one named Step with exactly-once-recorded, at-least-once-executed
+ * semantics: a committed result decodes through `output` and returns without
+ * executing the body; otherwise the body runs (a crash mid-body re-executes
+ * on the next Attempt), the success is encoded through `output`, and only
+ * then committed. The Schema argument is the canonical codec for the recorded
+ * result, not decoration. A Step never makes a non-idempotent external API
+ * exactly-once — the body must use the external system's idempotency key,
+ * reconciliation API, or compensating workflow.
+ */
+interface DurableStepService {
+  readonly do: <Output extends Schema.Top, BodyError, BodyServices>(name: string, output: Output, execute: Effect.Effect<Output["Type"], BodyError, BodyServices>) => Effect.Effect<Output["Type"], DurableStepError | BodyError, BodyServices | Output["DecodingServices"] | Output["EncodingServices"]>;
+}
+declare const DurableStep_base: Context.ServiceClass<DurableStep, "@effect-agent/engine/DurableStep", DurableStepService>;
+/**
+ * Engine-owned Durable Step seam.
+ *
+ * Declaring this service in `Tool.make({ dependencies: [DurableStep] })` is
+ * what makes a Tool a Durable Tool: its handler divides external effects into
+ * named Steps and may be re-entered after interruption. The engine provides
+ * the service locally to every Tool Call, bound to that call's identity; it
+ * is never satisfied from an application Layer and is excluded from the
+ * runtime's public requirements. Without a durable runtime the engine
+ * provides an ephemeral pass-through that executes each Step once and
+ * records nothing — the durable claim attaches to the runtime, not the Tool.
+ */
+declare class DurableStep extends DurableStep_base {}
+//#endregion
+export { PersistedStepResult as a, ToolExecutionClass as c, DurableStep_d_exports as i, ToolExecutionClassValue as l, DurableStepError as n, RunStepHook as o, DurableStepService as r, RunStepKey as s, DurableStep as t, getToolExecutionClass as u };
+//# sourceMappingURL=DurableStep-Cry_iol4.d.mts.map

package/dist/EventSource-BUYLmL77.d.mts

@@ -0,0 +1,51 @@
+import { O as PersistedJson } from "./Records-4qnRmniE.mjs";
+import { E as SubscriptionSourceError, b as SubscriptionRecord, i as EventSourceVersion, t as AcceptedEvent } from "./Subscription-pQUv0QD6.mjs";
+import { Context, Effect, Schema, Scope } from "effect";
+declare namespace EventSource_d_exports {
+  export { EventSource, EventSources, NormalizedEvent, makeEventSource };
+}
+interface NormalizedEvent {
+  readonly eventId: string;
+  readonly occurredAtMillis?: number;
+  readonly matchingKey: string;
+  readonly payload: PersistedJson;
+}
+/** Runtime-only versioned behavior. Never persist this object or silently replace its version. */
+interface EventSource {
+  readonly source: EventSourceVersion;
+  readonly continuity: string;
+  readonly parameters: (value: unknown) => Effect.Effect<{
+    readonly parameters: PersistedJson;
+    readonly matchingKey: string;
+  }, SubscriptionSourceError>;
+  readonly normalize: (value: unknown) => Effect.Effect<NormalizedEvent, SubscriptionSourceError>;
+  readonly matches: (event: AcceptedEvent, subscription: SubscriptionRecord) => Effect.Effect<boolean, SubscriptionSourceError>;
+  readonly reconcile?: (subscription: SubscriptionRecord) => Effect.Effect<NormalizedEvent | null, SubscriptionSourceError>;
+}
+declare const EventSources_base: Context.ServiceClass<EventSources, "@effect-agent/thread/EventSources", {
+  readonly sources: ReadonlyArray<EventSource>;
+}>;
+declare class EventSources extends EventSources_base {}
+/**
+ * Capture the source's explicit Effect dependencies at host assembly. Matching and key functions
+ * must be pure and bounded under this exact semantic version.
+ * The returned source accepts Schema-encoded values at intake and management boundaries.
+ * Each operation owns a fresh Scope for its callbacks and codecs; captured host services
+ * retain their host lifetime. Operation resources finalize on success, failure, or interruption.
+ */
+declare const makeEventSource: <Event extends Schema.Top, Parameters extends Schema.Top, R = never>(options: {
+  readonly source: EventSourceVersion;
+  readonly continuity: string;
+  readonly event: Event;
+  readonly parameters: Parameters;
+  readonly identity: (event: Event["Type"]) => string;
+  /** Authenticated source time, stable across delivery retries; required for bounded retention. */
+  readonly occurredAtMillis?: (event: Event["Type"]) => number | undefined;
+  readonly eventKey: (event: Event["Type"]) => string;
+  readonly parameterKey: (parameters: Parameters["Type"]) => string;
+  readonly matches: (event: Event["Type"], parameters: Parameters["Type"]) => boolean;
+  readonly reconcile?: (parameters: Parameters["Type"]) => Effect.Effect<Event["Type"] | null, SubscriptionSourceError, R>;
+}) => Effect.Effect<EventSource, never, Exclude<R, Scope.Scope> | Exclude<Event["DecodingServices"], Scope.Scope> | Exclude<Event["EncodingServices"], Scope.Scope> | Exclude<Parameters["DecodingServices"], Scope.Scope> | Exclude<Parameters["EncodingServices"], Scope.Scope>>;
+//#endregion
+export { makeEventSource as a, NormalizedEvent as i, EventSource_d_exports as n, EventSources as r, EventSource as t };
+//# sourceMappingURL=EventSource-BUYLmL77.d.mts.map

package/dist/FailureDiagnostic-BElLOoED.mjs

@@ -0,0 +1,274 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Cause, Exit, Predicate, Redacted, Schema, SchemaParser, SchemaTransformation } from "effect";
+//#region src/core/internal/strict-schema.ts
+/** Keep strict parsing on nested values even when an outer parser uses its defaults. */
+const strictSchema = (schema) => Schema.declareConstructor()([schema], ([codec]) => (value, _ast, options) => SchemaParser.decodeUnknownEffect(codec)(value, {
+	...options,
+	onExcessProperty: "error"
+}), { toCodecJson: ([codec]) => Schema.link()(codec, SchemaTransformation.passthrough()) });
+//#endregion
+//#region src/core/FailureDiagnostic.ts
+var FailureDiagnostic_exports = /* @__PURE__ */ __exportAll({
+	Cause: () => Cause$1,
+	Context: () => Context$1,
+	Diagnostic: () => Diagnostic,
+	Failure: () => Failure,
+	Value: () => Value,
+	capture: () => capture,
+	captureContext: () => captureContext,
+	redactText: () => redactText
+});
+const Text = Schema.String.check(Schema.isMaxLength(16384));
+const Name = Schema.String.check(Schema.isMaxLength(1024));
+const Scalar = Schema.Union([
+	Text,
+	Schema.Finite,
+	Schema.Boolean,
+	Schema.Null
+]);
+/** Correlation only: never include inputs, tool parameters, request bodies, or credentials. */
+const Context$1 = Schema.Struct({
+	agentId: Schema.optionalKey(Name),
+	threadId: Schema.optionalKey(Name),
+	runId: Schema.optionalKey(Name),
+	submissionId: Schema.optionalKey(Name),
+	attemptId: Schema.optionalKey(Name),
+	turnId: Schema.optionalKey(Name),
+	toolCallId: Schema.optionalKey(Name),
+	toolName: Schema.optionalKey(Name),
+	callId: Schema.optionalKey(Name),
+	check: Schema.optionalKey(Name),
+	operation: Schema.optionalKey(Name)
+}).pipe(strictSchema);
+const diagnosticSchema = (nested) => Schema.Union([
+	Schema.Struct({
+		_tag: Schema.Literal("Error"),
+		errorTag: Schema.optionalKey(Name),
+		name: Schema.optionalKey(Name),
+		message: Schema.optionalKey(Text),
+		stack: Schema.optionalKey(Text),
+		reason: Schema.optionalKey(nested),
+		code: Schema.optionalKey(Schema.Union([Name, Schema.Finite])),
+		cause: Schema.optionalKey(nested),
+		errors: Schema.optionalKey(Schema.Array(nested).check(Schema.isMaxLength(128))),
+		context: Schema.optionalKey(Context$1),
+		omittedFields: Schema.optionalKey(Schema.Array(Name).check(Schema.isMaxLength(32))),
+		truncated: Schema.optionalKey(Schema.Literal(true))
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Cause"),
+		reasons: Schema.Array(Schema.Union([
+			Schema.Struct({
+				_tag: Schema.Literal("Fail"),
+				error: nested
+			}),
+			Schema.Struct({
+				_tag: Schema.Literal("Die"),
+				defect: nested
+			}),
+			Schema.Struct({
+				_tag: Schema.Literal("Interrupt"),
+				fiberId: Schema.optionalKey(Schema.Finite)
+			})
+		])).check(Schema.isMaxLength(128)),
+		truncated: Schema.optionalKey(Schema.Literal(true))
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Value"),
+		value: Scalar
+	}),
+	Schema.Struct({
+		_tag: Schema.Literal("Omitted"),
+		reason: Schema.Literals([
+			"redacted",
+			"cycle",
+			"limit",
+			"unsupported"
+		])
+	})
+]);
+/** Structured, allowlisted Error fields and ordered Effect Fail/Die/Interrupt reasons. */
+const Diagnostic = Schema.suspend(() => diagnosticSchema(Diagnostic)).pipe(strictSchema);
+const decodeDiagnosticNode = Schema.decodeUnknownExit(diagnosticSchema(Schema.Unknown).pipe(strictSchema));
+/** Remove common credential forms; hosts must keep arbitrary private payloads out of error text. */
+const redactText = (text) => text.replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+/gi, "$1 [REDACTED]").replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, "$1[REDACTED]@").replace(/([?&](?:access_token|api_key|apikey|token|key|secret|password|signature)=)[^\s&#]*/gi, "$1[REDACTED]").replace(/\b((?:api[_-]?key|access[_-]?token|authorization|password|secret)\s*[=:]\s*)[^\s,;}]+/gi, "$1[REDACTED]");
+/**
+* Capture only diagnostic fields. Local values are never mutated. Cycles and exhausted limits
+* are explicit, not silently dropped; capture visits at most 1,024 nodes, with 56 JSON levels
+* and 128 KiB text. Inner causes have priority over outer stacks when the text budget is exhausted.
+* Text remains operator-private. No generic serializer can identify secrets embedded in arbitrary
+* prose: application error messages must exclude payloads, and hosts may supply stricter redaction.
+*/
+const capture = (value, options) => {
+	const seen = /* @__PURE__ */ new WeakSet();
+	let remainingNodes = 1024;
+	let remainingText = 131072;
+	const text = (value, limit = 16384) => {
+		const safe = (options?.redactText ?? redactText)(value);
+		const length = Math.max(0, Math.min(limit, remainingText));
+		const marker = "[truncated]".slice(0, length);
+		const result = safe.length <= length ? safe : `${safe.slice(0, length - marker.length)}${marker}`;
+		remainingText -= result.length;
+		return result;
+	};
+	const visit = (value, depth) => {
+		if (remainingNodes <= 0 || depth >= 56) return {
+			_tag: "Omitted",
+			reason: "limit"
+		};
+		remainingNodes--;
+		if (Redacted.isRedacted(value)) return {
+			_tag: "Omitted",
+			reason: "redacted"
+		};
+		if (Predicate.isString(value)) return {
+			_tag: "Value",
+			value: text(value)
+		};
+		if (value === null || Predicate.isBoolean(value) || Predicate.isNumber(value) && Number.isFinite(value)) return {
+			_tag: "Value",
+			value
+		};
+		if (!Predicate.isObject(value)) return {
+			_tag: "Omitted",
+			reason: "unsupported"
+		};
+		if (seen.has(value)) return {
+			_tag: "Omitted",
+			reason: "cycle"
+		};
+		seen.add(value);
+		const nested = (value) => visit(value, depth + 1);
+		const decoded = value instanceof Error ? void 0 : decodeDiagnosticNode(value);
+		const node = decoded !== void 0 && Exit.isSuccess(decoded) ? decoded.value : void 0;
+		if (node?._tag === "Omitted" || node?._tag === "Value") {
+			seen.delete(value);
+			return node._tag === "Value" && typeof node.value === "string" ? {
+				_tag: "Value",
+				value: text(node.value)
+			} : node;
+		}
+		const originalReasons = Cause.isCause(value) ? value.reasons : node?._tag === "Cause" ? node.reasons : void 0;
+		if (originalReasons !== void 0) {
+			const reasons = [];
+			for (const reason of originalReasons) {
+				if (reasons.length >= 128 || remainingNodes <= 0) break;
+				remainingNodes--;
+				switch (reason._tag) {
+					case "Fail":
+						reasons.push({
+							_tag: "Fail",
+							error: visit(reason.error, depth + 3)
+						});
+						break;
+					case "Die":
+						reasons.push({
+							_tag: "Die",
+							defect: visit(reason.defect, depth + 3)
+						});
+						break;
+					case "Interrupt": reasons.push({
+						_tag: "Interrupt",
+						...reason.fiberId === void 0 ? {} : { fiberId: reason.fiberId }
+					});
+				}
+			}
+			const result = {
+				_tag: "Cause",
+				...originalReasons.length > reasons.length || node?._tag === "Cause" && node.truncated ? { truncated: true } : {},
+				reasons
+			};
+			seen.delete(value);
+			return result;
+		}
+		const retained = node?._tag === "Error" ? node : void 0;
+		const omittedFields = [];
+		const read = (key) => {
+			try {
+				return Reflect.get(value, key);
+			} catch {
+				omittedFields.push(key);
+				return;
+			}
+		};
+		const tag = retained === void 0 ? read("_tag") : retained.errorTag;
+		const name = read("name");
+		const message = read("message");
+		const stack = read("stack");
+		const reason = read("reason");
+		const code = read("code");
+		const cause = read("cause");
+		const errors = read("errors");
+		const capturedCause = cause === void 0 ? void 0 : nested(cause);
+		const capturedReason = reason === void 0 ? void 0 : nested(reason);
+		const capturedErrors = [];
+		if (Array.isArray(errors)) for (const error of errors) {
+			if (capturedErrors.length >= 128 || remainingNodes <= 0) break;
+			capturedErrors.push(visit(error, depth + 2));
+		}
+		for (const field of retained?.omittedFields ?? []) omittedFields.push(text(field, 1024));
+		const context = {};
+		for (const key of [
+			"agentId",
+			"threadId",
+			"runId",
+			"submissionId",
+			"attemptId",
+			"turnId",
+			"toolCallId",
+			"toolName",
+			"callId",
+			"check",
+			"operation"
+		]) {
+			const field = retained === void 0 ? read(key) : retained.context?.[key];
+			if (Predicate.isString(field)) context[key] = text(field, 1024);
+		}
+		const result = {
+			_tag: "Error",
+			...Predicate.isString(tag) ? { errorTag: text(tag, 1024) } : {},
+			...Predicate.isString(name) ? { name: text(name, 1024) } : {},
+			...Predicate.isString(message) ? { message: text(message) } : {},
+			...Predicate.isString(stack) ? { stack: text(stack) } : {},
+			...capturedReason === void 0 ? {} : { reason: capturedReason },
+			...Predicate.isString(code) ? { code: text(code, 1024) } : Predicate.isNumber(code) && Number.isFinite(code) ? { code } : {},
+			...capturedCause === void 0 ? {} : { cause: capturedCause },
+			...Array.isArray(errors) ? { errors: capturedErrors } : {},
+			...Object.keys(context).length === 0 ? {} : { context },
+			...omittedFields.length === 0 ? {} : { omittedFields },
+			...retained?.truncated || Array.isArray(errors) && errors.length > capturedErrors.length || remainingText === 0 ? { truncated: true } : {}
+		};
+		seen.delete(value);
+		return result;
+	};
+	return visit(value, 0);
+};
+/** Bound and redact a diagnostic copy; canonical identities stay in their owning records. */
+const captureContext = (context) => {
+	const diagnostic = capture(context);
+	return diagnostic._tag === "Error" ? diagnostic.context ?? {} : {};
+};
+/**
+* Preserve the original value in-process; across JSON retain its structured diagnostic projection.
+* Decoding returns Diagnostic data, never claims to reconstruct an application error class.
+*/
+const Value = Diagnostic.pipe(Schema.decodeTo(Schema.Unknown, SchemaTransformation.transform({
+	decode: (diagnostic) => diagnostic,
+	encode: (value) => capture(value)
+})));
+/** Original local Effect Cause; its JSON codec preserves ordered typed, defect and interrupt reasons. */
+const Cause$1 = Schema.Cause(Value, Value).pipe(Schema.decodeTo(Schema.declare(Cause.isCause), SchemaTransformation.transform({
+	decode: (cause) => cause,
+	encode: (cause) => cause
+})));
+/** Safe summary plus optional operator-private causal evidence retained at a terminal boundary. */
+const Failure = Schema.Struct({
+	errorTag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	message: Text,
+	diagnostic: Schema.optionalKey(Diagnostic),
+	context: Schema.optionalKey(Context$1)
+}).pipe(strictSchema);
+//#endregion
+export { FailureDiagnostic_exports as a, captureContext as c, Failure as i, redactText as l, Context$1 as n, Value as o, Diagnostic as r, capture as s, Cause$1 as t, strictSchema as u };
+
+//# sourceMappingURL=FailureDiagnostic-BElLOoED.mjs.map

package/dist/FailureDiagnostic-BElLOoED.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FailureDiagnostic-BElLOoED.mjs","names":["Context","EffectCause","Cause"],"sources":["../src/core/internal/strict-schema.ts","../src/core/FailureDiagnostic.ts"],"sourcesContent":["import { Schema, SchemaParser, SchemaTransformation } from \"effect\";\n\n/** Keep strict parsing on nested values even when an outer parser uses its defaults. */\nexport const strictSchema = <S extends Schema.Top>(schema: S) =>\n  Schema.declareConstructor<S[\"Type\"], S[\"Encoded\"]>()(\n    [schema],\n    ([codec]) =>\n      (value, _ast, options) =>\n        SchemaParser.decodeUnknownEffect(codec)(value, { ...options, onExcessProperty: \"error\" }),\n    {\n      toCodecJson: ([codec]) =>\n        Schema.link<S[\"Encoded\"]>()(codec, SchemaTransformation.passthrough()),\n    },\n  );\n","import {\n  Cause as EffectCause,\n  Exit,\n  Predicate,\n  Redacted,\n  Schema,\n  SchemaTransformation,\n} from \"effect\";\n\nimport { strictSchema } from \"./internal/strict-schema.ts\";\n\nconst Text = Schema.String.check(Schema.isMaxLength(16 * 1024));\nconst Name = Schema.String.check(Schema.isMaxLength(1_024));\nconst Scalar = Schema.Union([Text, Schema.Finite, Schema.Boolean, Schema.Null]);\n\n/** Correlation only: never include inputs, tool parameters, request bodies, or credentials. */\nexport const Context = Schema.Struct({\n  agentId: Schema.optionalKey(Name),\n  threadId: Schema.optionalKey(Name),\n  runId: Schema.optionalKey(Name),\n  submissionId: Schema.optionalKey(Name),\n  attemptId: Schema.optionalKey(Name),\n  turnId: Schema.optionalKey(Name),\n  toolCallId: Schema.optionalKey(Name),\n  toolName: Schema.optionalKey(Name),\n  callId: Schema.optionalKey(Name),\n  check: Schema.optionalKey(Name),\n  operation: Schema.optionalKey(Name),\n}).pipe(strictSchema);\n\nexport type Context = typeof Context.Type;\n\ntype CauseReason =\n  | { readonly _tag: \"Fail\"; readonly error: Diagnostic }\n  | { readonly _tag: \"Die\"; readonly defect: Diagnostic }\n  | { readonly _tag: \"Interrupt\"; readonly fiberId?: number };\n\n/** A private diagnostic projection, not a JavaScript error reconstruction or model response. */\nexport type Diagnostic =\n  | {\n      readonly _tag: \"Error\";\n      readonly errorTag?: string;\n      readonly name?: string;\n      readonly message?: string;\n      readonly stack?: string;\n      readonly reason?: Diagnostic;\n      readonly code?: string | number;\n      readonly cause?: Diagnostic;\n      readonly errors?: ReadonlyArray<Diagnostic>;\n      readonly context?: Context;\n      readonly omittedFields?: ReadonlyArray<string>;\n      readonly truncated?: true;\n    }\n  | {\n      readonly _tag: \"Cause\";\n      readonly reasons: ReadonlyArray<CauseReason>;\n      readonly truncated?: true;\n    }\n  | { readonly _tag: \"Value\"; readonly value: string | number | boolean | null }\n  | { readonly _tag: \"Omitted\"; readonly reason: \"redacted\" | \"cycle\" | \"limit\" | \"unsupported\" };\n\nconst diagnosticSchema = <Nested extends Schema.Top>(nested: Nested) =>\n  Schema.Union([\n    Schema.Struct({\n      _tag: Schema.Literal(\"Error\"),\n      errorTag: Schema.optionalKey(Name),\n      name: Schema.optionalKey(Name),\n      message: Schema.optionalKey(Text),\n      stack: Schema.optionalKey(Text),\n      reason: Schema.optionalKey(nested),\n      code: Schema.optionalKey(Schema.Union([Name, Schema.Finite])),\n      cause: Schema.optionalKey(nested),\n      errors: Schema.optionalKey(Schema.Array(nested).check(Schema.isMaxLength(128))),\n      context: Schema.optionalKey(Context),\n      omittedFields: Schema.optionalKey(Schema.Array(Name).check(Schema.isMaxLength(32))),\n      truncated: Schema.optionalKey(Schema.Literal(true)),\n    }),\n    Schema.Struct({\n      _tag: Schema.Literal(\"Cause\"),\n      reasons: Schema.Array(\n        Schema.Union([\n          Schema.Struct({ _tag: Schema.Literal(\"Fail\"), error: nested }),\n          Schema.Struct({ _tag: Schema.Literal(\"Die\"), defect: nested }),\n          Schema.Struct({\n            _tag: Schema.Literal(\"Interrupt\"),\n            fiberId: Schema.optionalKey(Schema.Finite),\n          }),\n        ]),\n      ).check(Schema.isMaxLength(128)),\n      truncated: Schema.optionalKey(Schema.Literal(true)),\n    }),\n    Schema.Struct({ _tag: Schema.Literal(\"Value\"), value: Scalar }),\n    Schema.Struct({\n      _tag: Schema.Literal(\"Omitted\"),\n      reason: Schema.Literals([\"redacted\", \"cycle\", \"limit\", \"unsupported\"]),\n    }),\n  ]);\n\n/** Structured, allowlisted Error fields and ordered Effect Fail/Die/Interrupt reasons. */\nexport const Diagnostic: Schema.Codec<Diagnostic> = Schema.suspend(() =>\n  diagnosticSchema(Diagnostic),\n).pipe(strictSchema);\n\n// Inspect one encoded node only; recursion must share capture's depth/node/text budgets.\nconst decodeDiagnosticNode = Schema.decodeUnknownExit(\n  diagnosticSchema(Schema.Unknown).pipe(strictSchema),\n);\n\n/** Remove common credential forms; hosts must keep arbitrary private payloads out of error text. */\nexport const redactText = (text: string): string =>\n  text\n    .replace(/\\b(Bearer|Basic)\\s+[A-Za-z0-9._~+/=-]+/gi, \"$1 [REDACTED]\")\n    .replace(/(https?:\\/\\/)[^\\s/@]+:[^\\s/@]+@/gi, \"$1[REDACTED]@\")\n    .replace(\n      /([?&](?:access_token|api_key|apikey|token|key|secret|password|signature)=)[^\\s&#]*/gi,\n      \"$1[REDACTED]\",\n    )\n    .replace(\n      /\\b((?:api[_-]?key|access[_-]?token|authorization|password|secret)\\s*[=:]\\s*)[^\\s,;}]+/gi,\n      \"$1[REDACTED]\",\n    );\n\n/**\n * Capture only diagnostic fields. Local values are never mutated. Cycles and exhausted limits\n * are explicit, not silently dropped; capture visits at most 1,024 nodes, with 56 JSON levels\n * and 128 KiB text. Inner causes have priority over outer stacks when the text budget is exhausted.\n * Text remains operator-private. No generic serializer can identify secrets embedded in arbitrary\n * prose: application error messages must exclude payloads, and hosts may supply stricter redaction.\n */\nexport const capture = (\n  value: unknown,\n  options?: { readonly redactText?: (text: string) => string },\n): Diagnostic => {\n  const seen = new WeakSet<object>();\n  let remainingNodes = 1_024;\n  let remainingText = 128 * 1024;\n\n  const text = (value: string, limit = 16 * 1024): string => {\n    const safe = (options?.redactText ?? redactText)(value);\n    const length = Math.max(0, Math.min(limit, remainingText));\n\n    const marker = \"[truncated]\".slice(0, length);\n\n    const result =\n      safe.length <= length ? safe : `${safe.slice(0, length - marker.length)}${marker}`;\n\n    remainingText -= result.length;\n\n    return result;\n  };\n\n  const visit = (value: unknown, depth: number): Diagnostic => {\n    if (remainingNodes <= 0 || depth >= 56) return { _tag: \"Omitted\", reason: \"limit\" };\n    remainingNodes--;\n    if (Redacted.isRedacted(value)) return { _tag: \"Omitted\", reason: \"redacted\" };\n    if (Predicate.isString(value)) return { _tag: \"Value\", value: text(value) };\n    if (\n      value === null ||\n      Predicate.isBoolean(value) ||\n      (Predicate.isNumber(value) && Number.isFinite(value))\n    )\n      return { _tag: \"Value\", value };\n    if (!Predicate.isObject(value)) return { _tag: \"Omitted\", reason: \"unsupported\" };\n    if (seen.has(value)) return { _tag: \"Omitted\", reason: \"cycle\" };\n    seen.add(value);\n    const nested = (value: unknown) => visit(value, depth + 1);\n    // Local errors retain their own tag, even when it happens to be \"Error\".\n    const decoded = value instanceof Error ? undefined : decodeDiagnosticNode(value);\n    const node = decoded !== undefined && Exit.isSuccess(decoded) ? decoded.value : undefined;\n\n    if (node?._tag === \"Omitted\" || node?._tag === \"Value\") {\n      seen.delete(value);\n\n      return node._tag === \"Value\" && typeof node.value === \"string\"\n        ? { _tag: \"Value\", value: text(node.value) }\n        : node;\n    }\n\n    const originalReasons = EffectCause.isCause(value)\n      ? value.reasons\n      : node?._tag === \"Cause\"\n        ? node.reasons\n        : undefined;\n\n    if (originalReasons !== undefined) {\n      const reasons: Array<CauseReason> = [];\n\n      for (const reason of originalReasons) {\n        if (reasons.length >= 128 || remainingNodes <= 0) break;\n        remainingNodes--;\n\n        // reasons -> array item -> error/defect contributes three JSON levels.\n        switch (reason._tag) {\n          case \"Fail\":\n            reasons.push({ _tag: \"Fail\", error: visit(reason.error, depth + 3) });\n            break;\n          case \"Die\":\n            reasons.push({ _tag: \"Die\", defect: visit(reason.defect, depth + 3) });\n            break;\n          case \"Interrupt\":\n            reasons.push({\n              _tag: \"Interrupt\",\n              ...(reason.fiberId === undefined ? {} : { fiberId: reason.fiberId }),\n            });\n            break;\n        }\n      }\n\n      const result: Diagnostic = {\n        _tag: \"Cause\",\n        ...(originalReasons.length > reasons.length || (node?._tag === \"Cause\" && node.truncated)\n          ? { truncated: true }\n          : {}),\n        reasons,\n      };\n\n      seen.delete(value);\n\n      return result;\n    }\n    const retained = node?._tag === \"Error\" ? node : undefined;\n    const omittedFields: Array<string> = [];\n\n    const read = (key: string): unknown => {\n      // A throwing accessor must not replace the original failure during diagnostic capture.\n      try {\n        return Reflect.get(value, key);\n      } catch {\n        omittedFields.push(key);\n\n        return undefined;\n      }\n    };\n\n    const tag = retained === undefined ? read(\"_tag\") : retained.errorTag;\n    const name = read(\"name\");\n    const message = read(\"message\");\n    const stack = read(\"stack\");\n    const reason = read(\"reason\");\n    const code = read(\"code\");\n    const cause = read(\"cause\");\n    const errors = read(\"errors\");\n    const capturedCause = cause === undefined ? undefined : nested(cause);\n    const capturedReason = reason === undefined ? undefined : nested(reason);\n    const capturedErrors: Array<Diagnostic> = [];\n\n    if (Array.isArray(errors))\n      for (const error of errors) {\n        if (capturedErrors.length >= 128 || remainingNodes <= 0) break;\n        capturedErrors.push(visit(error, depth + 2));\n      }\n\n    for (const field of retained?.omittedFields ?? []) omittedFields.push(text(field, 1_024));\n\n    const context: Record<string, string> = {};\n\n    for (const key of [\n      \"agentId\",\n      \"threadId\",\n      \"runId\",\n      \"submissionId\",\n      \"attemptId\",\n      \"turnId\",\n      \"toolCallId\",\n      \"toolName\",\n      \"callId\",\n      \"check\",\n      \"operation\",\n    ] as const) {\n      const field = retained === undefined ? read(key) : retained.context?.[key];\n\n      if (Predicate.isString(field)) context[key] = text(field, 1_024);\n    }\n\n    const result: Diagnostic = {\n      _tag: \"Error\",\n      ...(Predicate.isString(tag) ? { errorTag: text(tag, 1_024) } : {}),\n      ...(Predicate.isString(name) ? { name: text(name, 1_024) } : {}),\n      ...(Predicate.isString(message) ? { message: text(message) } : {}),\n      ...(Predicate.isString(stack) ? { stack: text(stack) } : {}),\n      ...(capturedReason === undefined ? {} : { reason: capturedReason }),\n      ...(Predicate.isString(code)\n        ? { code: text(code, 1_024) }\n        : Predicate.isNumber(code) && Number.isFinite(code)\n          ? { code }\n          : {}),\n      ...(capturedCause === undefined ? {} : { cause: capturedCause }),\n      ...(Array.isArray(errors) ? { errors: capturedErrors } : {}),\n      ...(Object.keys(context).length === 0 ? {} : { context }),\n      ...(omittedFields.length === 0 ? {} : { omittedFields }),\n      ...(retained?.truncated ||\n      (Array.isArray(errors) && errors.length > capturedErrors.length) ||\n      remainingText === 0\n        ? { truncated: true }\n        : {}),\n    };\n\n    seen.delete(value);\n\n    return result;\n  };\n\n  return visit(value, 0);\n};\n\n/** Bound and redact a diagnostic copy; canonical identities stay in their owning records. */\nexport const captureContext = (context: Context): Context => {\n  const diagnostic = capture(context);\n\n  return diagnostic._tag === \"Error\" ? (diagnostic.context ?? {}) : {};\n};\n\n/**\n * Preserve the original value in-process; across JSON retain its structured diagnostic projection.\n * Decoding returns Diagnostic data, never claims to reconstruct an application error class.\n */\nexport const Value = Diagnostic.pipe(\n  Schema.decodeTo(\n    Schema.Unknown,\n    SchemaTransformation.transform({\n      decode: (diagnostic): unknown => diagnostic,\n      encode: (value: unknown) => capture(value),\n    }),\n  ),\n);\n\n/** Original local Effect Cause; its JSON codec preserves ordered typed, defect and interrupt reasons. */\nexport const Cause = Schema.Cause(Value, Value).pipe(\n  Schema.decodeTo(\n    Schema.declare<EffectCause.Cause<unknown>>(EffectCause.isCause),\n    SchemaTransformation.transform({ decode: (cause) => cause, encode: (cause) => cause }),\n  ),\n);\n\n/** Safe summary plus optional operator-private causal evidence retained at a terminal boundary. */\nexport const Failure = Schema.Struct({\n  errorTag: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  message: Text,\n  diagnostic: Schema.optionalKey(Diagnostic),\n  context: Schema.optionalKey(Context),\n}).pipe(strictSchema);\n\nexport type Failure = typeof Failure.Type;\n"],"mappings":"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"}