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

package/dist/engine/ContextCompactor.mjs

@@ -0,0 +1,119 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { a as SUMMARY_REQUEST_PREFIX, c as buildRolloverHandoff, d as collectCoveredMessages, g as evaluateMessageTokenEstimates, h as estimatePromptTokens, i as SUMMARY_MAX_LENGTH, l as choosePruneBound, o as SUMMARY_REQUEST_SUFFIX, s as buildCompactedView, u as chooseSummarizeCut, y as renderForSummary } from "../compaction-C2OTceKw.mjs";
+import { ContextHandoff } from "./ContextWindow.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { Context, Effect, Layer, Option, Schema, Stream } from "effect";
+//#region src/engine/ContextCompactor.ts
+var ContextCompactor_exports = /* @__PURE__ */ __exportAll({
+	CompactionDecision: () => CompactionDecision,
+	CompactionError: () => CompactionError,
+	ContextCompactor: () => ContextCompactor
+});
+/**
+* A proposed view change. Source indices are exclusive prefix bounds, never record sequences.
+* Summaries contain at most 65,536 characters; the interpreter rejects oversized decisions
+* before committing or changing coverage.
+*/
+const CompactionDecision = Schema.Union([
+	Schema.Struct({
+		kind: Schema.Literal("rollover"),
+		through: Schema.Natural,
+		handoff: Schema.optionalKey(ContextHandoff)
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("clear-tool-results"),
+		through: Schema.Natural
+	}),
+	Schema.Struct({
+		kind: Schema.Literal("summarize"),
+		through: Schema.Natural,
+		summary: Schema.NonEmptyString.check(Schema.isMaxLength(SUMMARY_MAX_LENGTH), Schema.isPattern(/\S/))
+	})
+]);
+/** Expected strategy or decision-validation failure. Causes stay in the live Effect only. */
+var CompactionError = class extends Schema.TaggedError()("CompactionError", {
+	message: Schema.String.check(Schema.isMaxLength(4096)),
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+const evaluateEstimates = (override, operation) => Effect.suspend(() => {
+	const result = evaluateMessageTokenEstimates(override, operation);
+	return Option.isSome(result) ? Effect.succeed(result.value) : CompactionError.make({ message: "Message token estimator returned an invalid token count" });
+});
+const defaultCompactor = (model) => ({
+	estimate: estimatePromptTokens,
+	compact: (request) => Stream.unwrap(Effect.gen(function* () {
+		const { source, policy, targetTokens, trigger, modelCallAllowed } = request;
+		if (request.requested !== void 0) return Stream.succeed({
+			kind: "rollover",
+			...request.requested
+		});
+		const forceSummarize = trigger === "overflow";
+		const state = { ...request.state };
+		const keepRecentTokens = targetTokens === void 0 ? policy.keepRecentTokens : Math.max(1, Math.min(policy.keepRecentTokens, targetTokens));
+		const decisions = [];
+		if (!forceSummarize && policy.mode !== "summarize") {
+			const through = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => choosePruneBound(source.content, state, keepRecentTokens, targetTokens, estimate));
+			if (through > state.clearedThrough) {
+				state.clearedThrough = through;
+				decisions.push({
+					kind: "clear-tool-results",
+					through
+				});
+				if (targetTokens !== void 0 && (yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => estimatePromptTokens(buildCompactedView(source.content, state), estimate))) <= targetTokens) return Stream.fromIterable(decisions);
+			}
+		}
+		const prune = Stream.fromIterable(decisions);
+		if ((!modelCallAllowed || policy.mode === "prune") && !forceSummarize) return prune;
+		return prune.pipe(Stream.concat(Stream.unwrap(Effect.gen(function* () {
+			const through = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => chooseSummarizeCut(source.content, state, keepRecentTokens, estimate));
+			const covered = collectCoveredMessages(source.content, state, through);
+			if (covered.length === 0) return Stream.empty;
+			const transcript = renderForSummary(covered, state.replacement?.kind === "summarize" ? state.replacement.summary : state.replacement?.handoff);
+			if (transcript === void 0) return yield* CompactionError.make({ message: `Previous compaction summary exceeds ${SUMMARY_MAX_LENGTH} characters` });
+			const prompt = Prompt.fromMessages([Prompt.userMessage({ content: [Prompt.textPart({ text: `${SUMMARY_REQUEST_PREFIX}${transcript}${SUMMARY_REQUEST_SUFFIX}` })] })]);
+			const text = yield* request.summarize(prompt, model);
+			return Stream.succeed({
+				kind: "summarize",
+				through,
+				summary: text.trim()
+			});
+		}))));
+	}))
+});
+/**
+* The sole interpreter compaction port. Runs without an installed service provide layer at their
+* composition boundary. Decorators yield this service during construction and receive their
+* underlying implementation through Layer.provide. Direct harnesses use the same Layer contract.
+*/
+var ContextCompactor = class ContextCompactor extends Context.Service()("@effect-agent/engine/ContextCompactor") {
+	static layer = Layer.succeed(ContextCompactor, defaultCompactor());
+	/**
+	* Start fresh windows without a summarizer call. The engine retains instructions/input and
+	* commits each boundary; a bounded emergency handoff preserves user inputs and unseen results.
+	* Applications provide notes/history tools alongside this strategy.
+	*/
+	static layerRollover = Layer.succeed(ContextCompactor, {
+		estimate: estimatePromptTokens,
+		compact: (request) => Stream.unwrap(Effect.gen(function* () {
+			if (request.requested !== void 0) return Stream.succeed({
+				kind: "rollover",
+				...request.requested
+			});
+			const through = request.source.content.findLastIndex((message) => message.role === "assistant" || message.role === "tool") + 1;
+			if (collectCoveredMessages(request.source.content, request.state, through).length === 0) return Stream.empty;
+			const handoff = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) => buildRolloverHandoff(request.source.content, request.state, request.targetTokens, through, estimate));
+			if (handoff === void 0) return Stream.fail(CompactionError.make({ message: "Insufficient context capacity for an automatic rollover handoff" }));
+			return Stream.succeed({
+				kind: "rollover",
+				through,
+				handoff
+			});
+		}))
+	});
+	/** Use the bounded default algorithm with a separate upstream Effect AI Model. */
+	static layerWithModel = (model) => Layer.effect(ContextCompactor, Effect.map(model.captureRequirements, (captured) => defaultCompactor(captured)));
+};
+//#endregion
+export { CompactionDecision, CompactionError, ContextCompactor, ContextCompactor_exports as t };
+
+//# sourceMappingURL=ContextCompactor.mjs.map

package/dist/engine/ContextCompactor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextCompactor.mjs","names":[],"sources":["../../src/engine/ContextCompactor.ts"],"sourcesContent":["import { Context, Effect, Layer, Option, Schema, Stream } from \"effect\";\nimport { type LanguageModel, type Model, Prompt } from \"effect/unstable/ai\";\n\nimport { type CompactionPolicy } from \"../core/AgentPolicy.ts\";\nimport { type RunId, type ThreadId } from \"../core/Identifiers.ts\";\nimport { ContextHandoff, type ContextRolloverRequest } from \"./ContextWindow.ts\";\nimport {\n  buildCompactedView,\n  buildRolloverHandoff,\n  choosePruneBound,\n  chooseSummarizeCut,\n  collectCoveredMessages,\n  estimatePromptTokens,\n  evaluateMessageTokenEstimates,\n  renderForSummary,\n  SUMMARY_MAX_LENGTH,\n  SUMMARY_REQUEST_PREFIX,\n  SUMMARY_REQUEST_SUFFIX,\n  type ContextCompactionState,\n} from \"./internal/compaction.ts\";\n\n/**\n * A proposed view change. Source indices are exclusive prefix bounds, never record sequences.\n * Summaries contain at most 65,536 characters; the interpreter rejects oversized decisions\n * before committing or changing coverage.\n */\nexport const CompactionDecision = Schema.Union([\n  Schema.Struct({\n    kind: Schema.Literal(\"rollover\"),\n    through: Schema.Natural,\n    handoff: Schema.optionalKey(ContextHandoff),\n  }),\n  Schema.Struct({ kind: Schema.Literal(\"clear-tool-results\"), through: Schema.Natural }),\n  Schema.Struct({\n    kind: Schema.Literal(\"summarize\"),\n    through: Schema.Natural,\n    summary: Schema.NonEmptyString.check(\n      Schema.isMaxLength(SUMMARY_MAX_LENGTH),\n      Schema.isPattern(/\\S/),\n    ),\n  }),\n]);\n\nexport type CompactionDecision = typeof CompactionDecision.Type;\n\n/** Expected strategy or decision-validation failure. Causes stay in the live Effect only. */\nexport class CompactionError extends Schema.TaggedError<CompactionError>()(\"CompactionError\", {\n  message: Schema.String.check(Schema.isMaxLength(4_096)),\n  cause: Schema.optionalKey(Schema.Defect()),\n}) {}\n\n/** Upstream Model.captureRequirements returns this closed Layer. */\nexport type CompactionModelLayer = Layer.Layer<\n  LanguageModel.LanguageModel | Model.ProviderName | Model.ModelName\n>;\n\n/** A full message estimate, or undefined to use the native structural estimate. */\nexport type ContextMessageTokenEstimator = (message: Prompt.Message) => number | undefined;\n\n/**\n * One bounded pass over an immutable source snapshot. A harness owns state, metering, and\n * application of decisions. The interpreter permits at most one prune followed by one replacement\n * (summary or rollover), and one call to summarize per Turn, shared across every trigger.\n * All model work must use summarize so it is metered.\n * Callback failures and requirements pass through unchanged; strategy dependencies belong to\n * its construction Layer. Protected messages cannot be removed and Tool pairs cannot be split by a decision.\n */\nexport interface CompactionRequest<E, R> {\n  readonly threadId: ThreadId;\n  readonly runId: RunId;\n  readonly turn: number;\n  readonly source: Prompt.Prompt;\n  readonly state: Readonly<ContextCompactionState>;\n  readonly policy: CompactionPolicy;\n  readonly targetTokens: number | undefined;\n  readonly trigger: \"pressure\" | \"overflow\" | \"requested\";\n  /** Budget admission may prohibit a separate model call while still allowing a rollover. */\n  readonly modelCallAllowed: boolean;\n  /** The current captured Model's message accounting, including native fallback. */\n  readonly estimateMessageTokens?: ContextMessageTokenEstimator | undefined;\n  /** Present for a successful, singleton context rollover Tool; through excludes later steering. */\n  readonly requested?: (ContextRolloverRequest & { readonly through: number }) | undefined;\n  readonly summarize: (\n    prompt: Prompt.Prompt,\n    model?: CompactionModelLayer,\n  ) => Effect.Effect<string, E, R>;\n}\n\nexport interface ContextCompaction {\n  /** Non-negative finite integer estimate, used for admission and derived prompt overhead too. */\n  readonly estimate: (messages: ReadonlyArray<Prompt.Message>) => number;\n  /** Emit decisions sequentially; the consumer commits each before pulling the next. */\n  readonly compact: <E, R>(\n    request: CompactionRequest<E, R>,\n  ) => Stream.Stream<CompactionDecision, E | CompactionError, R>;\n}\n\nconst evaluateEstimates = <A>(\n  override: ContextMessageTokenEstimator | undefined,\n  operation: (estimate: (message: Prompt.Message) => number) => A,\n): Effect.Effect<A, CompactionError> =>\n  Effect.suspend(() => {\n    const result = evaluateMessageTokenEstimates(override, operation);\n\n    return Option.isSome(result)\n      ? Effect.succeed(result.value)\n      : CompactionError.make({\n          message: \"Message token estimator returned an invalid token count\",\n        });\n  });\n\nconst defaultCompactor = (model?: CompactionModelLayer): ContextCompaction => ({\n  estimate: estimatePromptTokens,\n  compact: <E, R>(request: CompactionRequest<E, R>) =>\n    Stream.unwrap(\n      Effect.gen(function* () {\n        const { source, policy, targetTokens, trigger, modelCallAllowed } = request;\n\n        if (request.requested !== undefined) {\n          return Stream.succeed({ kind: \"rollover\", ...request.requested });\n        }\n        const forceSummarize = trigger === \"overflow\";\n        const state = { ...request.state };\n\n        const keepRecentTokens =\n          targetTokens === undefined\n            ? policy.keepRecentTokens\n            : Math.max(1, Math.min(policy.keepRecentTokens, targetTokens));\n\n        const decisions: Array<CompactionDecision> = [];\n\n        if (!forceSummarize && policy.mode !== \"summarize\") {\n          const through = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) =>\n            choosePruneBound(source.content, state, keepRecentTokens, targetTokens, estimate),\n          );\n\n          if (through > state.clearedThrough) {\n            state.clearedThrough = through;\n            decisions.push({ kind: \"clear-tool-results\", through });\n            if (\n              targetTokens !== undefined &&\n              (yield* evaluateEstimates(request.estimateMessageTokens, (estimate) =>\n                estimatePromptTokens(buildCompactedView(source.content, state), estimate),\n              )) <= targetTokens\n            ) {\n              return Stream.fromIterable(decisions);\n            }\n          }\n        }\n        const prune = Stream.fromIterable(decisions);\n\n        if ((!modelCallAllowed || policy.mode === \"prune\") && !forceSummarize) return prune;\n\n        return prune.pipe(\n          Stream.concat(\n            Stream.unwrap(\n              Effect.gen(function* () {\n                const through = yield* evaluateEstimates(\n                  request.estimateMessageTokens,\n                  (estimate) =>\n                    chooseSummarizeCut(source.content, state, keepRecentTokens, estimate),\n                );\n\n                const covered = collectCoveredMessages(source.content, state, through);\n\n                if (covered.length === 0) return Stream.empty;\n\n                const transcript = renderForSummary(\n                  covered,\n                  state.replacement?.kind === \"summarize\"\n                    ? state.replacement.summary\n                    : state.replacement?.handoff,\n                );\n\n                if (transcript === undefined) {\n                  return yield* CompactionError.make({\n                    message: `Previous compaction summary exceeds ${SUMMARY_MAX_LENGTH} characters`,\n                  });\n                }\n\n                const prompt = Prompt.fromMessages([\n                  Prompt.userMessage({\n                    content: [\n                      Prompt.textPart({\n                        text: `${SUMMARY_REQUEST_PREFIX}${transcript}${SUMMARY_REQUEST_SUFFIX}`,\n                      }),\n                    ],\n                  }),\n                ]);\n\n                const text = yield* request.summarize(prompt, model);\n\n                return Stream.succeed({\n                  kind: \"summarize\",\n                  through,\n                  summary: text.trim(),\n                } satisfies CompactionDecision);\n              }),\n            ),\n          ),\n        );\n      }),\n    ),\n});\n\n/**\n * The sole interpreter compaction port. Runs without an installed service provide layer at their\n * composition boundary. Decorators yield this service during construction and receive their\n * underlying implementation through Layer.provide. Direct harnesses use the same Layer contract.\n */\nexport class ContextCompactor extends Context.Service<ContextCompactor, ContextCompaction>()(\n  \"@effect-agent/engine/ContextCompactor\",\n) {\n  static readonly layer = Layer.succeed(ContextCompactor, defaultCompactor());\n\n  /**\n   * Start fresh windows without a summarizer call. The engine retains instructions/input and\n   * commits each boundary; a bounded emergency handoff preserves user inputs and unseen results.\n   * Applications provide notes/history tools alongside this strategy.\n   */\n  static readonly layerRollover = Layer.succeed(ContextCompactor, {\n    estimate: estimatePromptTokens,\n    compact: <E, R>(request: CompactionRequest<E, R>) =>\n      Stream.unwrap(\n        Effect.gen(function* () {\n          if (request.requested !== undefined) {\n            return Stream.succeed({\n              kind: \"rollover\",\n              ...request.requested,\n            } satisfies CompactionDecision);\n          }\n\n          // Trailing user steering may not be canonical until the next response. Keep it verbatim.\n          const through =\n            request.source.content.findLastIndex(\n              (message) => message.role === \"assistant\" || message.role === \"tool\",\n            ) + 1;\n\n          if (collectCoveredMessages(request.source.content, request.state, through).length === 0) {\n            return Stream.empty;\n          }\n\n          const handoff = yield* evaluateEstimates(request.estimateMessageTokens, (estimate) =>\n            buildRolloverHandoff(\n              request.source.content,\n              request.state,\n              request.targetTokens,\n              through,\n              estimate,\n            ),\n          );\n\n          if (handoff === undefined)\n            return Stream.fail(\n              CompactionError.make({\n                message: \"Insufficient context capacity for an automatic rollover handoff\",\n              }),\n            );\n\n          return Stream.succeed({\n            kind: \"rollover\",\n            through,\n            handoff,\n          } satisfies CompactionDecision);\n        }),\n      ),\n  });\n\n  /** Use the bounded default algorithm with a separate upstream Effect AI Model. */\n  static readonly layerWithModel = <Provider, Requirements>(\n    model: Model.Model<Provider, LanguageModel.LanguageModel, Requirements>,\n  ): Layer.Layer<ContextCompactor, never, Requirements> =>\n    Layer.effect(\n      ContextCompactor,\n      Effect.map(model.captureRequirements, (captured) => defaultCompactor(captured)),\n    );\n}\n"],"mappings":"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"}

package/dist/engine/ContextHistory.d.mts

@@ -0,0 +1,65 @@
+import { Context, Effect, Schema } from "effect";
+declare namespace ContextHistory_d_exports {
+  export { ContextHistory, ContextHistoryError, ContextHistoryHit, ContextHistoryPage, ContextHistoryRead, ContextHistorySearch };
+}
+declare const ContextHistoryError_base: Schema.Class<ContextHistoryError, Schema.TaggedStruct<"ContextHistoryError", {
+  readonly reason: Schema.Literals<readonly ["unavailable", "not-found", "invalid-input", "limit"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Canonical transcript lookup failure. Access to a Thread remains a host authorization decision. */
+declare class ContextHistoryError extends ContextHistoryError_base {}
+declare const ContextHistoryHit_base: Schema.Class<ContextHistoryHit, Schema.Struct<{
+  readonly recordId: Schema.NonEmptyString;
+  readonly windowId: Schema.NonEmptyString;
+  readonly text: Schema.String;
+}>, {}>;
+declare class ContextHistoryHit extends ContextHistoryHit_base {}
+declare const ContextHistorySearch_base: Schema.Class<ContextHistorySearch, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly query: Schema.NonEmptyString;
+  readonly limit: Schema.Int;
+  readonly beforeRecordId: Schema.optionalKey<Schema.NonEmptyString>;
+}>, {}>;
+/**
+ * Newest-first literal substring search, trimmed and JavaScript case-folded (not FTS or regex).
+ * `beforeRecordId` excludes that record and every newer canonical position. Use the last hit
+ * from the previous page with the same query; fewer than `limit` hits (including zero) ends
+ * pagination. A full final page requires one more request to observe the empty page.
+ *
+ * The anchor must be eligible retained evidence in this authorized Thread, but need not match
+ * the query. Unknown, removed, foreign, and non-evidence anchors fail with `not-found`.
+ * IDs are opaque: adapters resolve and verify the canonical source, never sort or parse IDs.
+ * Each request captures its own tail; this is not a snapshot held across requests. New appends
+ * cannot displace matches older than the anchor. Retention and authorization are rechecked.
+ */
+declare class ContextHistorySearch extends ContextHistorySearch_base {}
+declare const ContextHistoryRead_base: Schema.Class<ContextHistoryRead, Schema.Struct<{
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly recordId: Schema.NonEmptyString;
+  readonly offset: Schema.Natural;
+  readonly maxChars: Schema.Int;
+}>, {}>;
+declare class ContextHistoryRead extends ContextHistoryRead_base {}
+declare const ContextHistoryPage_base: Schema.Class<ContextHistoryPage, Schema.Struct<{
+  readonly recordId: Schema.NonEmptyString;
+  readonly windowId: Schema.NonEmptyString;
+  readonly text: Schema.String;
+  readonly nextOffset: Schema.NullOr<Schema.Natural>;
+}>, {}>;
+declare class ContextHistoryPage extends ContextHistoryPage_base {}
+declare const ContextHistory_base: Context.ServiceClass<ContextHistory, "@effect-agent/engine/ContextHistory", {
+  readonly search: (request: ContextHistorySearch) => Effect.Effect<ReadonlyArray<ContextHistoryHit>, ContextHistoryError>;
+  readonly read: (request: ContextHistoryRead) => Effect.Effect<ContextHistoryPage, ContextHistoryError>;
+}>;
+/**
+ * Read-only access to retained canonical evidence, including closed context windows.
+ * Adapters bind storage and authorization; model parameters must not select a different Thread.
+ * Returned text is untrusted evidence, never instructions. This port does not retain raw Tool
+ * output that was discarded before canonical persistence, or transient prompt references.
+ * Search adapters must honor the exclusive `beforeRecordId` bound, return a complete bounded
+ * page, or fail explicitly; silently ignoring the bound can trap callers on the latest matches.
+ */
+declare class ContextHistory extends ContextHistory_base {}
+//#endregion
+export { ContextHistory, ContextHistoryError, ContextHistoryHit, ContextHistoryPage, ContextHistoryRead, ContextHistorySearch, ContextHistory_d_exports as t };
+//# sourceMappingURL=ContextHistory.d.mts.map

package/dist/engine/ContextHistory.mjs

@@ -0,0 +1,76 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ThreadId } from "../core/Identifiers.mjs";
+import { Context, Schema } from "effect";
+//#region src/engine/ContextHistory.ts
+var ContextHistory_exports = /* @__PURE__ */ __exportAll({
+	ContextHistory: () => ContextHistory,
+	ContextHistoryError: () => ContextHistoryError,
+	ContextHistoryHit: () => ContextHistoryHit,
+	ContextHistoryPage: () => ContextHistoryPage,
+	ContextHistoryRead: () => ContextHistoryRead,
+	ContextHistorySearch: () => ContextHistorySearch
+});
+/** Canonical transcript lookup failure. Access to a Thread remains a host authorization decision. */
+var ContextHistoryError = class extends Schema.TaggedError()("ContextHistoryError", {
+	reason: Schema.Literals([
+		"unavailable",
+		"not-found",
+		"invalid-input",
+		"limit"
+	]),
+	message: Schema.String.check(Schema.isMaxLength(4096))
+}) {};
+var ContextHistoryHit = class extends Schema.Class("ContextHistoryHit")({
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	text: Schema.String.check(Schema.isMaxLength(2e3))
+}) {};
+/**
+* Newest-first literal substring search, trimmed and JavaScript case-folded (not FTS or regex).
+* `beforeRecordId` excludes that record and every newer canonical position. Use the last hit
+* from the previous page with the same query; fewer than `limit` hits (including zero) ends
+* pagination. A full final page requires one more request to observe the empty page.
+*
+* The anchor must be eligible retained evidence in this authorized Thread, but need not match
+* the query. Unknown, removed, foreign, and non-evidence anchors fail with `not-found`.
+* IDs are opaque: adapters resolve and verify the canonical source, never sort or parse IDs.
+* Each request captures its own tail; this is not a snapshot held across requests. New appends
+* cannot displace matches older than the anchor. Retention and authorization are rechecked.
+*/
+var ContextHistorySearch = class extends Schema.Class("ContextHistorySearch")({
+	threadId: ThreadId,
+	query: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	limit: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 20
+	})),
+	beforeRecordId: Schema.optionalKey(ContextHistoryHit.fields.recordId)
+}) {};
+var ContextHistoryRead = class extends Schema.Class("ContextHistoryRead")({
+	threadId: ThreadId,
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	offset: Schema.Natural,
+	maxChars: Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 2e4
+	}))
+}) {};
+var ContextHistoryPage = class extends Schema.Class("ContextHistoryPage")({
+	recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	text: Schema.String.check(Schema.isMaxLength(2e4)),
+	nextOffset: Schema.NullOr(Schema.Natural)
+}) {};
+/**
+* Read-only access to retained canonical evidence, including closed context windows.
+* Adapters bind storage and authorization; model parameters must not select a different Thread.
+* Returned text is untrusted evidence, never instructions. This port does not retain raw Tool
+* output that was discarded before canonical persistence, or transient prompt references.
+* Search adapters must honor the exclusive `beforeRecordId` bound, return a complete bounded
+* page, or fail explicitly; silently ignoring the bound can trap callers on the latest matches.
+*/
+var ContextHistory = class extends Context.Service()("@effect-agent/engine/ContextHistory") {};
+//#endregion
+export { ContextHistory, ContextHistoryError, ContextHistoryHit, ContextHistoryPage, ContextHistoryRead, ContextHistorySearch, ContextHistory_exports as t };
+
+//# sourceMappingURL=ContextHistory.mjs.map

package/dist/engine/ContextHistory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextHistory.mjs","names":[],"sources":["../../src/engine/ContextHistory.ts"],"sourcesContent":["import { Context, type Effect, Schema } from \"effect\";\n\nimport { ThreadId } from \"../core/Identifiers.ts\";\n\n/** Canonical transcript lookup failure. Access to a Thread remains a host authorization decision. */\nexport class ContextHistoryError extends Schema.TaggedError<ContextHistoryError>()(\n  \"ContextHistoryError\",\n  {\n    reason: Schema.Literals([\"unavailable\", \"not-found\", \"invalid-input\", \"limit\"]),\n    message: Schema.String.check(Schema.isMaxLength(4_096)),\n  },\n) {}\n\nexport class ContextHistoryHit extends Schema.Class<ContextHistoryHit>(\"ContextHistoryHit\")({\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  text: Schema.String.check(Schema.isMaxLength(2_000)),\n}) {}\n\n/**\n * Newest-first literal substring search, trimmed and JavaScript case-folded (not FTS or regex).\n * `beforeRecordId` excludes that record and every newer canonical position. Use the last hit\n * from the previous page with the same query; fewer than `limit` hits (including zero) ends\n * pagination. A full final page requires one more request to observe the empty page.\n *\n * The anchor must be eligible retained evidence in this authorized Thread, but need not match\n * the query. Unknown, removed, foreign, and non-evidence anchors fail with `not-found`.\n * IDs are opaque: adapters resolve and verify the canonical source, never sort or parse IDs.\n * Each request captures its own tail; this is not a snapshot held across requests. New appends\n * cannot displace matches older than the anchor. Retention and authorization are rechecked.\n */\nexport class ContextHistorySearch extends Schema.Class<ContextHistorySearch>(\n  \"ContextHistorySearch\",\n)({\n  threadId: ThreadId,\n  query: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  limit: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 20 })),\n  beforeRecordId: Schema.optionalKey(ContextHistoryHit.fields.recordId),\n}) {}\n\nexport class ContextHistoryRead extends Schema.Class<ContextHistoryRead>(\"ContextHistoryRead\")({\n  threadId: ThreadId,\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  offset: Schema.Natural,\n  maxChars: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 20_000 })),\n}) {}\n\nexport class ContextHistoryPage extends Schema.Class<ContextHistoryPage>(\"ContextHistoryPage\")({\n  recordId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  text: Schema.String.check(Schema.isMaxLength(20_000)),\n  nextOffset: Schema.NullOr(Schema.Natural),\n}) {}\n\n/**\n * Read-only access to retained canonical evidence, including closed context windows.\n * Adapters bind storage and authorization; model parameters must not select a different Thread.\n * Returned text is untrusted evidence, never instructions. This port does not retain raw Tool\n * output that was discarded before canonical persistence, or transient prompt references.\n * Search adapters must honor the exclusive `beforeRecordId` bound, return a complete bounded\n * page, or fail explicitly; silently ignoring the bound can trap callers on the latest matches.\n */\nexport class ContextHistory extends Context.Service<\n  ContextHistory,\n  {\n    readonly search: (\n      request: ContextHistorySearch,\n    ) => Effect.Effect<ReadonlyArray<ContextHistoryHit>, ContextHistoryError>;\n    readonly read: (\n      request: ContextHistoryRead,\n    ) => Effect.Effect<ContextHistoryPage, ContextHistoryError>;\n  }\n>()(\"@effect-agent/engine/ContextHistory\") {}\n"],"mappings":";;;;;;;;;;;;;AAKA,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,QAAQ,OAAO,SAAS;EAAC;EAAe;EAAa;EAAiB;CAAO,CAAC;CAC9E,SAAS,OAAO,OAAO,MAAM,OAAO,YAAY,IAAK,CAAC;AACxD,CACF,CAAC,CAAC,CAAC;AAEH,IAAa,oBAAb,cAAuC,OAAO,MAAyB,mBAAmB,CAAC,CAAC;CAC1F,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,MAAM,OAAO,OAAO,MAAM,OAAO,YAAY,GAAK,CAAC;AACrD,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;AAcJ,IAAa,uBAAb,cAA0C,OAAO,MAC/C,sBACF,CAAC,CAAC;CACA,UAAU;CACV,OAAO,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC1D,OAAO,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAG,CAAC,CAAC;CACrE,gBAAgB,OAAO,YAAY,kBAAkB,OAAO,QAAQ;AACtE,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,qBAAb,cAAwC,OAAO,MAA0B,oBAAoB,CAAC,CAAC;CAC7F,UAAU;CACV,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,QAAQ,OAAO;CACf,UAAU,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAO,CAAC,CAAC;AAC9E,CAAC,CAAC,CAAC,CAAC;AAEJ,IAAa,qBAAb,cAAwC,OAAO,MAA0B,oBAAoB,CAAC,CAAC;CAC7F,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,MAAM,OAAO,OAAO,MAAM,OAAO,YAAY,GAAM,CAAC;CACpD,YAAY,OAAO,OAAO,OAAO,OAAO;AAC1C,CAAC,CAAC,CAAC,CAAC;;;;;;;;;AAUJ,IAAa,iBAAb,cAAoC,QAAQ,QAU1C,CAAC,CAAC,qCAAqC,CAAC,CAAC,CAAC"}

package/dist/engine/ContextWindow.d.mts

@@ -0,0 +1,2 @@
+import { a as ContextWindow, c as ModelCallContext, i as ContextRolloverTool, n as ContextRolloverRequest, o as ContextWindowStatus, r as ContextRolloverSelection, t as ContextHandoff } from "../ContextWindow-DRQ5Mbm2.mjs";
+export { ContextHandoff, ContextRolloverRequest, ContextRolloverSelection, ContextRolloverTool, ContextWindow, ContextWindowStatus, ModelCallContext };

package/dist/engine/ContextWindow.mjs

@@ -0,0 +1,59 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { RunId, ThreadId } from "../core/Identifiers.mjs";
+import { Context, Encoding, Schema } from "effect";
+//#region src/engine/ContextWindow.ts
+var ContextWindow_exports = /* @__PURE__ */ __exportAll({
+	ContextHandoff: () => ContextHandoff,
+	ContextRolloverRequest: () => ContextRolloverRequest,
+	ContextRolloverSelection: () => ContextRolloverSelection,
+	ContextRolloverTool: () => ContextRolloverTool,
+	ContextWindow: () => ContextWindow,
+	ContextWindowStatus: () => ContextWindowStatus,
+	ModelCallContext: () => ModelCallContext
+});
+/** Model-authored continuation state; fuller notes belong in an application-owned memory store. */
+const ContextHandoff = Schema.NonEmptyString.check(Schema.isMaxLength(2e4), Schema.isPattern(/\S/), Schema.makeFilter((text) => Encoding.encodeHex(JSON.stringify(text)).length / 2 <= 32768, { expected: "at most 32768 JSON-encoded UTF-8 bytes" }));
+/** Successful output of an explicitly designated context-window Tool. */
+const ContextRolloverRequest = Schema.Struct({ handoff: Schema.optionalKey(ContextHandoff) });
+/**
+* Host-selected exclusive source-message boundary, applied at the next safe model seam.
+* Omit through to reset the prefix before the protected current instructions/input. The
+* engine resolves that prefix after preparation; an empty prior prefix needs no new window.
+*/
+const ContextRolloverSelection = Schema.Struct({
+	...ContextRolloverRequest.fields,
+	through: Schema.optionalKey(Schema.Natural)
+});
+/**
+* Bounds resolved alongside the native model for one Turn. Output reserve must match the
+* selected provider configuration. Uncounted overhead includes only provider framing or image
+* token costs absent from the prompt estimate; prompt text, output contracts, and native Tool
+* schemas are counted by the engine. These are live-context bounds, not cumulative Run budgets.
+*/
+var ModelCallContext = class extends Schema.Class("ModelCallContext")({
+	contextCapacity: Schema.Int.check(Schema.isGreaterThan(0)),
+	maxInputTokens: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+	outputReserveTokens: Schema.Natural,
+	uncountedOverheadTokens: Schema.Natural
+}) {};
+/**
+* Definition-owned control annotation. A successful singleton application Tool carrying this
+* annotation returns ContextRolloverRequest. The engine applies it at the next Turn seam,
+* including after durable Tool-result replay. A Tool name alone never grants this authority.
+*/
+const ContextRolloverTool = Context.Reference("@effect-agent/engine/ContextRolloverTool", { defaultValue: () => false });
+/** Best available live-context estimate, independent of cumulative Run budgets. */
+var ContextWindowStatus = class extends Schema.Class("ContextWindowStatus")({
+	threadId: ThreadId,
+	runId: RunId,
+	windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),
+	estimatedTokens: Schema.Natural,
+	contextTokenLimit: Schema.NullOr(Schema.Natural),
+	remainingTokens: Schema.NullOr(Schema.Natural)
+}) {};
+/** Engine-owned identity and context accounting for the current Run. */
+var ContextWindow = class extends Context.Service()("@effect-agent/engine/ContextWindow") {};
+//#endregion
+export { ContextHandoff, ContextRolloverRequest, ContextRolloverSelection, ContextRolloverTool, ContextWindow, ContextWindowStatus, ModelCallContext, ContextWindow_exports as t };
+
+//# sourceMappingURL=ContextWindow.mjs.map

package/dist/engine/ContextWindow.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextWindow.mjs","names":[],"sources":["../../src/engine/ContextWindow.ts"],"sourcesContent":["import { Context, type Effect, Encoding, Schema } from \"effect\";\n\nimport { RunId, ThreadId } from \"../core/Identifiers.ts\";\n\n/** Model-authored continuation state; fuller notes belong in an application-owned memory store. */\nexport const ContextHandoff = Schema.NonEmptyString.check(\n  Schema.isMaxLength(20_000),\n  Schema.isPattern(/\\S/),\n  Schema.makeFilter((text) => Encoding.encodeHex(JSON.stringify(text)).length / 2 <= 32_768, {\n    expected: \"at most 32768 JSON-encoded UTF-8 bytes\",\n  }),\n);\n\n/** Successful output of an explicitly designated context-window Tool. */\nexport const ContextRolloverRequest = Schema.Struct({\n  handoff: Schema.optionalKey(ContextHandoff),\n});\n\nexport type ContextRolloverRequest = typeof ContextRolloverRequest.Type;\n\n/**\n * Host-selected exclusive source-message boundary, applied at the next safe model seam.\n * Omit through to reset the prefix before the protected current instructions/input. The\n * engine resolves that prefix after preparation; an empty prior prefix needs no new window.\n */\nexport const ContextRolloverSelection = Schema.Struct({\n  ...ContextRolloverRequest.fields,\n  through: Schema.optionalKey(Schema.Natural),\n});\n\nexport type ContextRolloverSelection = typeof ContextRolloverSelection.Type;\n\n/**\n * Bounds resolved alongside the native model for one Turn. Output reserve must match the\n * selected provider configuration. Uncounted overhead includes only provider framing or image\n * token costs absent from the prompt estimate; prompt text, output contracts, and native Tool\n * schemas are counted by the engine. These are live-context bounds, not cumulative Run budgets.\n */\nexport class ModelCallContext extends Schema.Class<ModelCallContext>(\"ModelCallContext\")({\n  contextCapacity: Schema.Int.check(Schema.isGreaterThan(0)),\n  maxInputTokens: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),\n  outputReserveTokens: Schema.Natural,\n  uncountedOverheadTokens: Schema.Natural,\n}) {}\n\n/**\n * Definition-owned control annotation. A successful singleton application Tool carrying this\n * annotation returns ContextRolloverRequest. The engine applies it at the next Turn seam,\n * including after durable Tool-result replay. A Tool name alone never grants this authority.\n */\nexport const ContextRolloverTool = Context.Reference<boolean>(\n  \"@effect-agent/engine/ContextRolloverTool\",\n  { defaultValue: () => false },\n);\n\n/** Best available live-context estimate, independent of cumulative Run budgets. */\nexport class ContextWindowStatus extends Schema.Class<ContextWindowStatus>(\"ContextWindowStatus\")({\n  threadId: ThreadId,\n  runId: RunId,\n  windowId: Schema.NonEmptyString.check(Schema.isMaxLength(256)),\n  estimatedTokens: Schema.Natural,\n  contextTokenLimit: Schema.NullOr(Schema.Natural),\n  remainingTokens: Schema.NullOr(Schema.Natural),\n}) {}\n\n/** Engine-owned identity and context accounting for the current Run. */\nexport class ContextWindow extends Context.Service<\n  ContextWindow,\n  {\n    readonly status: Effect.Effect<ContextWindowStatus>;\n  }\n>()(\"@effect-agent/engine/ContextWindow\") {}\n"],"mappings":";;;;;;;;;;;;;;AAKA,MAAa,iBAAiB,OAAO,eAAe,MAClD,OAAO,YAAY,GAAM,GACzB,OAAO,UAAU,IAAI,GACrB,OAAO,YAAY,SAAS,SAAS,UAAU,KAAK,UAAU,IAAI,CAAC,CAAC,CAAC,SAAS,KAAK,OAAQ,EACzF,UAAU,yCACZ,CAAC,CACH;;AAGA,MAAa,yBAAyB,OAAO,OAAO,EAClD,SAAS,OAAO,YAAY,cAAc,EAC5C,CAAC;;;;;;AASD,MAAa,2BAA2B,OAAO,OAAO;CACpD,GAAG,uBAAuB;CAC1B,SAAS,OAAO,YAAY,OAAO,OAAO;AAC5C,CAAC;;;;;;;AAUD,IAAa,mBAAb,cAAsC,OAAO,MAAwB,kBAAkB,CAAC,CAAC;CACvF,iBAAiB,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;CACzD,gBAAgB,OAAO,YAAY,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC,CAAC;CAC5E,qBAAqB,OAAO;CAC5B,yBAAyB,OAAO;AAClC,CAAC,CAAC,CAAC,CAAC;;;;;;AAOJ,MAAa,sBAAsB,QAAQ,UACzC,4CACA,EAAE,oBAAoB,MAAM,CAC9B;;AAGA,IAAa,sBAAb,cAAyC,OAAO,MAA2B,qBAAqB,CAAC,CAAC;CAChG,UAAU;CACV,OAAO;CACP,UAAU,OAAO,eAAe,MAAM,OAAO,YAAY,GAAG,CAAC;CAC7D,iBAAiB,OAAO;CACxB,mBAAmB,OAAO,OAAO,OAAO,OAAO;CAC/C,iBAAiB,OAAO,OAAO,OAAO,OAAO;AAC/C,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,gBAAb,cAAmC,QAAQ,QAKzC,CAAC,CAAC,oCAAoC,CAAC,CAAC,CAAC"}

package/dist/engine/DurableStep.d.mts

@@ -0,0 +1,2 @@
+import { a as PersistedStepResult, c as ToolExecutionClass, l as ToolExecutionClassValue, n as DurableStepError, o as RunStepHook, r as DurableStepService, s as RunStepKey, t as DurableStep, u as getToolExecutionClass } from "../DurableStep-Cry_iol4.mjs";
+export { DurableStep, DurableStepError, DurableStepService, PersistedStepResult, RunStepHook, RunStepKey, ToolExecutionClass, ToolExecutionClassValue, getToolExecutionClass };

package/dist/engine/DurableStep.mjs

@@ -0,0 +1,62 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ToolCallId } from "../core/Identifiers.mjs";
+import { Context, Schema } from "effect";
+//#region src/engine/DurableStep.ts
+var DurableStep_exports = /* @__PURE__ */ __exportAll({
+	DurableStep: () => DurableStep,
+	DurableStepError: () => DurableStepError,
+	ToolExecutionClass: () => ToolExecutionClass,
+	getToolExecutionClass: () => getToolExecutionClass
+});
+/**
+* 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.
+*/
+const ToolExecutionClass = Context.Reference("@effect-agent/engine/ToolExecutionClass", { defaultValue: () => "uncertain" });
+/** Read a Tool's declared execution class, falling back to the fail-closed `"uncertain"` default. */
+const getToolExecutionClass = (tool) => Context.get(tool.annotations, ToolExecutionClass);
+/**
+* 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.
+*/
+var DurableStepError = class extends Schema.TaggedError()("DurableStepError", {
+	stepName: Schema.String,
+	reason: Schema.Literals([
+		"duplicate-step-name",
+		"lookup-failed",
+		"recorded-result-invalid",
+		"output-encoding-failed",
+		"commit-failed",
+		"no-active-tool-call"
+	]),
+	message: Schema.String.check(Schema.isMaxLength(4096)),
+	toolCallId: Schema.optionalKey(ToolCallId),
+	/** Diagnostic cause for the live Effect only; Run events retain the fixed public message. */
+	cause: Schema.optionalKey(Schema.Defect())
+}) {};
+/**
+* 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.
+*/
+var DurableStep = class extends Context.Service()("@effect-agent/engine/DurableStep") {};
+//#endregion
+export { DurableStep, DurableStepError, ToolExecutionClass, getToolExecutionClass, DurableStep_exports as t };
+
+//# sourceMappingURL=DurableStep.mjs.map

package/dist/engine/DurableStep.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DurableStep.mjs","names":[],"sources":["../../src/engine/DurableStep.ts"],"sourcesContent":["import { Context, Schema } from \"effect\";\nimport type { Effect, Option } from \"effect\";\nimport type { Tool } from \"effect/unstable/ai\";\n\nimport { ToolCallId } from \"../core/Identifiers.ts\";\n\n/**\n * Declared external execution class of one Tool, used by the durable runtime\n * to decide which Tool Calls need the prepared/settled uncertainty protocol:\n *\n * - `\"readonly\"`: the handler performs no external mutation. A crash between\n *   start and settlement is a free re-run; no prepared record is written.\n * - `\"idempotent\"`: the handler declares an external idempotency contract\n *   (it owns key derivation). Prepared/settled records are written and\n *   recovery may re-execute without reconciliation proof.\n * - `\"uncertain\"`: no external contract is declared. Prepared/settled records\n *   are written and recovery must reconcile or record an Unknown Outcome.\n */\nexport type ToolExecutionClassValue = \"readonly\" | \"idempotent\" | \"uncertain\";\n\n/**\n * Effect AI Tool annotation key declaring a Tool's execution class, applied\n * with `Tool.annotate(ToolExecutionClass, \"...\")`.\n *\n * Unannotated Tools default to `\"uncertain\"`: security and durability\n * decisions are fail-closed, so the framework never infers a safer class\n * from a Tool's shape.\n */\nexport const ToolExecutionClass = Context.Reference<ToolExecutionClassValue>(\n  \"@effect-agent/engine/ToolExecutionClass\",\n  { defaultValue: () => \"uncertain\" },\n);\n\n/** Read a Tool's declared execution class, falling back to the fail-closed `\"uncertain\"` default. */\nexport const getToolExecutionClass = (tool: Tool.Any): ToolExecutionClassValue =>\n  Context.get(tool.annotations, ToolExecutionClass);\n\n/** Stable identity of one Step within one Tool Call: `(toolCallId, stepName)`. */\nexport interface RunStepKey {\n  readonly toolCallId: ToolCallId;\n  readonly stepName: string;\n}\n\n/** A previously committed Step result in its canonical encoded form. */\nexport interface PersistedStepResult {\n  readonly encodedOutput: unknown;\n}\n\n/**\n * Dependency-neutral Step persistence seam implemented by a durable\n * coordinator and consumed by the engine-provided `DurableStep` service.\n *\n * `lookup` returns the committed result for a Step identity when one exists;\n * `commit` durably records one successful encoded output. Only success is\n * ever committed — recording failures would replay a transient failure\n * forever. Both operations are keyed by the deterministic `RunStepKey`, so\n * replays and racing writers dedupe on record identity in the adapter.\n */\nexport interface RunStepHook<Error = never, Requirements = never> {\n  readonly lookup: (\n    key: RunStepKey,\n  ) => Effect.Effect<Option.Option<PersistedStepResult>, Error, Requirements>;\n  readonly commit: (\n    key: RunStepKey,\n    encodedOutput: unknown,\n  ) => Effect.Effect<void, Error, Requirements>;\n}\n\n/**\n * Typed failure of one `DurableStep.do` call.\n *\n * `duplicate-step-name` is an identity conflict: Step names must be\n * deterministic and unique within one Tool Call, and reuse would silently\n * replay another Step's recorded result. `recorded-result-invalid` is the\n * replay-with-different-content conflict: a committed result that no longer\n * decodes through the declared output Schema is never silently accepted.\n */\nexport class DurableStepError extends Schema.TaggedError<DurableStepError>()(\"DurableStepError\", {\n  stepName: Schema.String,\n  reason: Schema.Literals([\n    \"duplicate-step-name\",\n    \"lookup-failed\",\n    \"recorded-result-invalid\",\n    \"output-encoding-failed\",\n    \"commit-failed\",\n    \"no-active-tool-call\",\n  ]),\n  message: Schema.String.check(Schema.isMaxLength(4_096)),\n  toolCallId: Schema.optionalKey(ToolCallId),\n  /** Diagnostic cause for the live Effect only; Run events retain the fixed public message. */\n  cause: Schema.optionalKey(Schema.Defect()),\n}) {}\n\n/**\n * Service value provided locally by the engine to each Tool Call's handler.\n *\n * `do` runs one named Step with exactly-once-recorded, at-least-once-executed\n * semantics: a committed result decodes through `output` and returns without\n * executing the body; otherwise the body runs (a crash mid-body re-executes\n * on the next Attempt), the success is encoded through `output`, and only\n * then committed. The Schema argument is the canonical codec for the recorded\n * result, not decoration. A Step never makes a non-idempotent external API\n * exactly-once — the body must use the external system's idempotency key,\n * reconciliation API, or compensating workflow.\n */\nexport interface DurableStepService {\n  readonly do: <Output extends Schema.Top, BodyError, BodyServices>(\n    name: string,\n    output: Output,\n    execute: Effect.Effect<Output[\"Type\"], BodyError, BodyServices>,\n  ) => Effect.Effect<\n    Output[\"Type\"],\n    DurableStepError | BodyError,\n    BodyServices | Output[\"DecodingServices\"] | Output[\"EncodingServices\"]\n  >;\n}\n\n/**\n * Engine-owned Durable Step seam.\n *\n * Declaring this service in `Tool.make({ dependencies: [DurableStep] })` is\n * what makes a Tool a Durable Tool: its handler divides external effects into\n * named Steps and may be re-entered after interruption. The engine provides\n * the service locally to every Tool Call, bound to that call's identity; it\n * is never satisfied from an application Layer and is excluded from the\n * runtime's public requirements. Without a durable runtime the engine\n * provides an ephemeral pass-through that executes each Step once and\n * records nothing — the durable claim attaches to the runtime, not the Tool.\n */\nexport class DurableStep extends Context.Service<DurableStep, DurableStepService>()(\n  \"@effect-agent/engine/DurableStep\",\n) {}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA4BA,MAAa,qBAAqB,QAAQ,UACxC,2CACA,EAAE,oBAAoB,YAAY,CACpC;;AAGA,MAAa,yBAAyB,SACpC,QAAQ,IAAI,KAAK,aAAa,kBAAkB;;;;;;;;;;AA0ClD,IAAa,mBAAb,cAAsC,OAAO,YAA8B,CAAC,CAAC,oBAAoB;CAC/F,UAAU,OAAO;CACjB,QAAQ,OAAO,SAAS;EACtB;EACA;EACA;EACA;EACA;EACA;CACF,CAAC;CACD,SAAS,OAAO,OAAO,MAAM,OAAO,YAAY,IAAK,CAAC;CACtD,YAAY,OAAO,YAAY,UAAU;;CAEzC,OAAO,OAAO,YAAY,OAAO,OAAO,CAAC;AAC3C,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;;AAsCJ,IAAa,cAAb,cAAiC,QAAQ,QAAyC,CAAC,CACjF,kCACF,CAAC,CAAC,CAAC"}

package/dist/engine/MessagingHost.d.mts

@@ -0,0 +1,2 @@
+import { a as PeerDeliveryLifetime, c as PeerTarget, i as PeerAuthorizer, l as SendPeerMessage, o as PeerMessageCapacity, r as PeerAuthorizationRequest, s as PeerRoutes, t as MessagingHost } from "../MessagingHost-CRk0kXzT.mjs";
+export { MessagingHost, PeerAuthorizationRequest, PeerAuthorizer, PeerDeliveryLifetime, PeerMessageCapacity, PeerRoutes, PeerTarget, SendPeerMessage };

package/dist/engine/MessagingHost.mjs

@@ -0,0 +1,2 @@
+import { a as PeerMessageCapacity, i as PeerDeliveryLifetime, o as PeerRoutes, r as PeerAuthorizer, t as MessagingHost } from "../MessagingHost-CWi_PP3g.mjs";
+export { MessagingHost, PeerAuthorizer, PeerDeliveryLifetime, PeerMessageCapacity, PeerRoutes };

package/dist/engine/Output.d.mts

@@ -0,0 +1,2 @@
+import { n as textOutput } from "../Output-D6SkedVx.mjs";
+export { textOutput as text };

package/dist/engine/Output.mjs

@@ -0,0 +1,8 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { i as textOutput } from "../output-contract-BC7tjlGw.mjs";
+//#region src/engine/Output.ts
+var Output_exports = /* @__PURE__ */ __exportAll({ text: () => textOutput });
+//#endregion
+export { Output_exports as t, textOutput as text };
+
+//# sourceMappingURL=Output.mjs.map

package/dist/engine/Output.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Output.mjs","names":[],"sources":["../../src/engine/Output.ts"],"sourcesContent":["/** Schema-owned final-output formats for Agent definitions. */\nexport { textOutput as text } from \"./internal/output-contract.ts\";\n"],"mappings":""}

package/dist/engine/RunEventSink.d.mts

@@ -0,0 +1,2 @@
+import { a as SubagentCompletedPayload, c as SubagentFailedPayload, d as SubagentProgressPayload, f as SubagentRequestedPayload, l as SubagentInterruptedPayload, n as RunEventSinkClosedError, o as SubagentEventBasePayload, p as SubagentStartedPayload, r as RunEventSinkService, s as SubagentEventPayload, t as RunEventSink, u as SubagentJoinedPayload } from "../RunEventSink-D5aVhISG.mjs";
+export { RunEventSink, RunEventSinkClosedError, RunEventSinkService, SubagentCompletedPayload, SubagentEventBasePayload, SubagentEventPayload, SubagentFailedPayload, SubagentInterruptedPayload, SubagentJoinedPayload, SubagentProgressPayload, SubagentRequestedPayload, SubagentStartedPayload };

package/dist/engine/RunEventSink.mjs

@@ -0,0 +1,22 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Schema } from "effect";
+//#region src/engine/RunEventSink.ts
+var RunEventSink_exports = /* @__PURE__ */ __exportAll({
+	RunEventSink: () => RunEventSink,
+	RunEventSinkClosedError: () => RunEventSinkClosedError
+});
+/** A handler emitted a Subagent event after its Tool batch had already settled. */
+var RunEventSinkClosedError = class extends Schema.TaggedError()("RunEventSinkClosedError", { message: Schema.String }) {};
+/**
+* Engine-owned seam through which Tool handlers emit Subagent lifecycle
+* events onto the parent Run stream.
+*
+* The engine provides this service locally to every Tool batch, bound to that
+* batch's Run identity and Turn; it is never satisfied from an application
+* Layer and is excluded from the runtime's public requirements.
+*/
+var RunEventSink = class extends Context.Service()("@effect-agent/engine/RunEventSink") {};
+//#endregion
+export { RunEventSink, RunEventSinkClosedError, RunEventSink_exports as t };
+
+//# sourceMappingURL=RunEventSink.mjs.map

package/dist/engine/RunEventSink.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunEventSink.mjs","names":[],"sources":["../../src/engine/RunEventSink.ts"],"sourcesContent":["import { Context, Schema } from \"effect\";\nimport type { Effect } from \"effect\";\n\nimport {\n  type AgentId,\n  type ThreadId,\n  type DelegationId,\n  type RunId,\n  type ToolCallId,\n} from \"../core/Identifiers.ts\";\nimport { type DelegationDepth } from \"../core/SubagentContract.ts\";\nimport { type RunTotals } from \"../core/Usage.ts\";\n\n/**\n * Shared identity carried by every pre-base Subagent event payload. The\n * emitting Tool handler supplies delegation lineage and its own Tool Call\n * identity; the engine stamps the remaining fields it is authoritative for\n * (`eventVersion`, `runId`, `threadId`, `agentId`, `sequence`,\n * `timestamp`, and the emitting batch's `turnId`) when the payload is woven\n * into the parent stream.\n */\nexport interface SubagentEventBasePayload {\n  readonly toolCallId: ToolCallId;\n  readonly delegationId: DelegationId;\n  readonly childThreadId: ThreadId;\n  readonly childRunId: RunId;\n  readonly targetAgentId: AgentId;\n  readonly depth: DelegationDepth;\n}\n\n/** Pre-base payload for the core `SubagentRequested` event. */\nexport interface SubagentRequestedPayload extends SubagentEventBasePayload {\n  readonly _tag: \"SubagentRequested\";\n}\n\n/** Pre-base payload for the core `SubagentStarted` event. */\nexport interface SubagentStartedPayload extends SubagentEventBasePayload {\n  readonly _tag: \"SubagentStarted\";\n}\n\n/** Pre-base payload for the core `SubagentProgress` event; `summary` is at most 4096 characters. */\nexport interface SubagentProgressPayload extends SubagentEventBasePayload {\n  readonly _tag: \"SubagentProgress\";\n  readonly summary: string;\n}\n\n/** Pre-base payload for the core `SubagentCompleted` event; `turns` is a positive integer. */\nexport interface SubagentCompletedPayload extends SubagentEventBasePayload {\n  readonly _tag: \"SubagentCompleted\";\n  readonly turns: number;\n  readonly finishReason: \"completed\" | \"model-stop\" | \"budget-exhausted\";\n  /** Dimension that bound when the child settled budget-exhausted (the RUN-021 grant-flow marker). */\n  readonly exhausted?: \"tokens\" | \"tool-calls\" | \"turns\" | undefined;\n  /** What the child spent, so a parent can account for delegated work. */\n  readonly usage?: RunTotals | undefined;\n  readonly delegatedUsage?: RunTotals | undefined;\n}\n\n/** Pre-base payload for the core `SubagentFailed` event; `message` is at most 4096 characters. */\nexport interface SubagentFailedPayload extends SubagentEventBasePayload {\n  readonly _tag: \"SubagentFailed\";\n  readonly usage?: RunTotals | undefined;\n  readonly delegatedUsage?: RunTotals | undefined;\n  readonly errorTag: string;\n  readonly message: string;\n}\n\n/** Pre-base payload for the core `SubagentInterrupted` event; `reason` is at most 4096 characters. */\nexport interface SubagentInterruptedPayload extends SubagentEventBasePayload {\n  readonly _tag: \"SubagentInterrupted\";\n  readonly usage?: RunTotals | undefined;\n  readonly delegatedUsage?: RunTotals | undefined;\n  readonly reason: string;\n}\n\n/** Pre-base payload for the core `SubagentJoined` event. */\nexport interface SubagentJoinedPayload extends SubagentEventBasePayload {\n  readonly _tag: \"SubagentJoined\";\n  readonly usage?: RunTotals | undefined;\n  readonly delegatedUsage?: RunTotals | undefined;\n}\n\n/**\n * Discriminated union of pre-base Subagent lifecycle event payloads accepted\n * by `RunEventSink.emit`. Each variant is the corresponding core `RunEvent`\n * class minus the base fields the engine stamps. The stamped event is\n * constructed through the core Schema class, so core field checks (bounded\n * text, positive turns) still apply; violating them is a defect of the\n * emitting handler, not an expected failure.\n */\nexport type SubagentEventPayload =\n  | SubagentRequestedPayload\n  | SubagentStartedPayload\n  | SubagentProgressPayload\n  | SubagentCompletedPayload\n  | SubagentFailedPayload\n  | SubagentInterruptedPayload\n  | SubagentJoinedPayload;\n\n/** A handler emitted a Subagent event after its Tool batch had already settled. */\nexport class RunEventSinkClosedError extends Schema.TaggedError<RunEventSinkClosedError>()(\n  \"RunEventSinkClosedError\",\n  {\n    message: Schema.String,\n  },\n) {}\n\n/**\n * Service value accepted by Tool handlers to emit first-class Subagent\n * lifecycle events into the parent Run's semantic stream.\n *\n * The sink is backed by a bounded queue drained by the Run's own event stream.\n * A burst may suspend the emitting handler until that internal stream drains\n * capacity, but an external detached observer cannot backpressure the Tool\n * batch. Emitting after the owning Tool batch has settled — or outside any\n * Tool batch — fails closed with `RunEventSinkClosedError`.\n */\nexport interface RunEventSinkService {\n  readonly emit: (payload: SubagentEventPayload) => Effect.Effect<void, RunEventSinkClosedError>;\n}\n\n/**\n * Engine-owned seam through which Tool handlers emit Subagent lifecycle\n * events onto the parent Run stream.\n *\n * The engine provides this service locally to every Tool batch, bound to that\n * batch's Run identity and Turn; it is never satisfied from an application\n * Layer and is excluded from the runtime's public requirements.\n */\nexport class RunEventSink extends Context.Service<RunEventSink, RunEventSinkService>()(\n  \"@effect-agent/engine/RunEventSink\",\n) {}\n"],"mappings":";;;;;;;;AAoGA,IAAa,0BAAb,cAA6C,OAAO,YAAqC,CAAC,CACxF,2BACA,EACE,SAAS,OAAO,OAClB,CACF,CAAC,CAAC,CAAC;;;;;;;;;AAwBH,IAAa,eAAb,cAAkC,QAAQ,QAA2C,CAAC,CACpF,mCACF,CAAC,CAAC,CAAC"}

package/dist/engine/RunOptions.d.mts

@@ -0,0 +1,2 @@
+import { $ as RunTurnResponseCommit, A as RunInputCommand, B as RunSubagentChildIdentity, C as RunContextPreparationPassthrough, D as RunCostEstimateValue, E as RunCostEstimateRequest, G as RunToolAuthorization, H as RunSubagentEstablishRequest, I as RunResumeUsage, J as RunToolAuthorizationRequest, K as RunToolAuthorizationDecision, L as RunResumeUsageSchema, M as RunOptions, N as RunOptionsError, O as RunCostEstimator, P as RunOptionsRequirements, Q as RunTransientContextHook, R as RunSchedulingHook, S as RunContextPreparationError, T as RunCostEstimate, U as RunSubagentHook, V as RunSubagentDigests, W as RunSubagentJoinRequest, X as RunToolFailureObserver, Y as RunToolCallDescriptor, Z as RunToolScheduling, _ as RunBudgetHook, a as ChildEstablishWaiting, at as RunUsageDelta, b as RunContextHook, c as ModelToolFailure, d as ProgrammaticPreflightFailure, et as RunTurnResume, f as ProgrammaticToolFailure, g as RunApprovalRequest, h as RunApprovalHook, i as ChildEstablishStatus, it as RunTurnUsage, j as RunInputHook, k as RunDurabilityHook, l as ModelUsageAccounting, m as RunApprovalDecision, n as ChildEstablishDenied, nt as RunTurnResumeSettledCall, o as CommandDrainPolicy, ot as ToolFailureObservation, p as ResolvedModelCall, q as RunToolAuthorizationHook, r as ChildEstablishSettled, rt as RunTurnResumeSettledCallSchema, s as CurrentToolFailureObserver, st as toolFailureObserverLayer, t as AgentUpdateAcceptance, tt as RunTurnResumeCall, u as PreparedRunContext, v as RunBufferLimits, w as RunContextRequest, x as RunContextPreparation, y as RunCompactionCommit, z as RunSchedulingOverride } from "../RunOptions-g1aigcKI.mjs";
+export { AgentUpdateAcceptance, ChildEstablishDenied, ChildEstablishSettled, ChildEstablishStatus, ChildEstablishWaiting, CommandDrainPolicy, CurrentToolFailureObserver, ModelToolFailure, ModelUsageAccounting, PreparedRunContext, ProgrammaticPreflightFailure, ProgrammaticToolFailure, ResolvedModelCall, RunApprovalDecision, RunApprovalHook, RunApprovalRequest, RunBudgetHook, RunBufferLimits, RunCompactionCommit, RunContextHook, RunContextPreparation, RunContextPreparationError, RunContextPreparationPassthrough, RunContextRequest, RunCostEstimate, RunCostEstimateRequest, RunCostEstimateValue, RunCostEstimator, RunDurabilityHook, RunInputCommand, RunInputHook, RunOptions, RunOptionsError, RunOptionsRequirements, RunResumeUsage, RunResumeUsageSchema, RunSchedulingHook, RunSchedulingOverride, RunSubagentChildIdentity, RunSubagentDigests, RunSubagentEstablishRequest, RunSubagentHook, RunSubagentJoinRequest, RunToolAuthorization, RunToolAuthorizationDecision, RunToolAuthorizationHook, RunToolAuthorizationRequest, RunToolCallDescriptor, RunToolFailureObserver, RunToolScheduling, RunTransientContextHook, RunTurnResponseCommit, RunTurnResume, RunTurnResumeCall, RunTurnResumeSettledCall, RunTurnResumeSettledCallSchema, RunTurnUsage, RunUsageDelta, ToolFailureObservation, toolFailureObserverLayer };