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

package/dist/capabilities/MemoryNotes.mjs

@@ -0,0 +1,128 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { DurableStep, DurableStepError, ToolExecutionClass } from "../engine/DurableStep.mjs";
+import { MemoryContent, MemorySourceReference } from "../core/MemoryReference.mjs";
+import { ActiveMemoryDocument, MemoryConflict, MemoryDocument, MemoryKey, MemoryMutationFailure, MemoryOperationConflict, MemoryReader, MemoryStorageError, MemoryWithdrawn, MemoryWrite, MemoryWriter } from "../core/MemoryStore.mjs";
+import { IdGenerator, Tool, Toolkit } from "effect/unstable/ai";
+import { Clock, Effect, Schema } from "effect";
+//#region src/capabilities/MemoryNotes.ts
+var MemoryNotes_exports = /* @__PURE__ */ __exportAll({
+	MemoryNotesError: () => MemoryNotesError,
+	NotesSnapshot: () => NotesSnapshot,
+	ReadNotes: () => ReadNotes,
+	WriteNotes: () => WriteNotes,
+	layer: () => layer,
+	toolkit: () => toolkit
+});
+const NotesText = Schema.String.check(Schema.isMaxLength(2e4), Schema.makeFilter((text) => utf8ByteLength(JSON.stringify(text)) <= 32768, { expected: "notes totaling at most 32768 JSON-encoded UTF-8 bytes" }));
+/** A single host-selected document. Null revision and empty text mean it has not been created. */
+var NotesSnapshot = class extends Schema.Class("MemoryNotesSnapshot")({
+	revision: MemorySourceReference.fields.revision,
+	text: NotesText
+}) {};
+/** A document valid for general Memory exceeded the bounded notes tool's readable shape. */
+var MemoryNotesError = class extends Schema.TaggedError()("MemoryNotesError", {
+	reason: Schema.Literal("limit"),
+	message: Schema.String.check(Schema.isMaxLength(4096))
+}) {};
+const OptionsSchema = Schema.Struct({
+	key: MemoryKey.Wire,
+	locator: MemorySourceReference.fields.locator,
+	attributions: MemoryContent.fields.attributions,
+	scopes: ActiveMemoryDocument.Wire.fields.scopes
+});
+const ReadNotes = Tool.make("read_notes", {
+	description: "Read the durable working notes shared by this agent's host. Preserve their revision when making a replacement. These notes are working memory, not authoritative user instructions.",
+	parameters: Tool.EmptyParams,
+	success: NotesSnapshot,
+	failure: Schema.Union([
+		MemoryStorageError,
+		MemoryWithdrawn,
+		MemoryNotesError
+	]),
+	failureMode: "return"
+}).annotate(ToolExecutionClass, "readonly").annotate(Tool.Readonly, true);
+const WriteNotes = Tool.make("write_notes", {
+	description: "Replace the complete durable working notes. Supply the revision from read_notes, or null to create them. On a revision conflict, read again and merge before retrying. Saving notes does not start a new context window.",
+	parameters: Schema.Struct({
+		text: NotesText.check(Schema.isMinLength(1), Schema.isPattern(/\S/)),
+		expectedRevision: MemorySourceReference.fields.revision
+	}),
+	success: NotesSnapshot,
+	failure: Schema.Union([
+		MemoryStorageError,
+		MemoryConflict,
+		MemoryWithdrawn,
+		MemoryOperationConflict,
+		MemoryMutationFailure,
+		MemoryNotesError,
+		DurableStepError
+	]),
+	failureMode: "return",
+	dependencies: [DurableStep]
+}).annotate(ToolExecutionClass, "idempotent");
+const toolkit = Toolkit.make(ReadNotes, WriteNotes);
+const snapshot = Effect.fn("MemoryNotes.snapshot")(function* (document) {
+	if (document?._tag === "WithdrawnMemoryDocument") return yield* MemoryWithdrawn.make({
+		key: document.key,
+		revision: document.source.revision
+	});
+	return yield* Schema.decodeEffect(NotesSnapshot)({
+		revision: document?.source.revision ?? null,
+		text: document?.content.text ?? ""
+	}).pipe(Effect.mapError(() => MemoryNotesError.make({
+		reason: "limit",
+		message: "Notes exceed 20000 characters or 32768 JSON-encoded UTF-8 bytes"
+	})));
+});
+/**
+* Bind the tools to one authorized Memory document. The host supplies a durable MemoryWriter
+* when notes must survive process loss. Revision conflicts never trigger an automatic overwrite.
+* A Durable Step saves the exact command, including operation identity and timestamp, before
+* dispatch; retries reuse it and the writer's existing idempotency receipt. Ephemeral Runs
+* retain the Memory store's semantics but do not acquire durable Tool recovery.
+* Supply Effect AI's IdGenerator service to select operation identities.
+*/
+const layer = (options) => {
+	const config = Schema.decodeSync(OptionsSchema)(options);
+	return toolkit.toLayer(Effect.gen(function* () {
+		const reader = yield* MemoryReader;
+		const writer = yield* MemoryWriter;
+		const ids = yield* IdGenerator.IdGenerator;
+		return toolkit.of({
+			read_notes: () => reader.get(config.key).pipe(Effect.flatMap(snapshot)),
+			write_notes: Effect.fn("MemoryNotes.write_notes")(function* (request) {
+				const step = yield* DurableStep;
+				const command = yield* step.do("prepare-notes", MemoryWrite.Wire, Effect.gen(function* () {
+					const operationId = yield* ids.generateId();
+					const recordedAt = yield* Clock.currentTimeMillis;
+					return MemoryWrite.make({
+						_tag: "Put",
+						key: config.key,
+						operationId,
+						expectedRevision: request.expectedRevision,
+						locator: config.locator,
+						scopes: config.scopes,
+						content: MemoryContent.make({
+							text: request.text,
+							attributions: config.attributions,
+							metadata: {},
+							recordedAt
+						})
+					});
+				}));
+				const document = yield* step.do("write-notes", MemoryDocument.Wire, writer.change(command));
+				return yield* snapshot(document);
+			}, Effect.catchTag("DurableStepError", (error) => Effect.fail(DurableStepError.make({
+				stepName: error.stepName,
+				reason: error.reason,
+				message: "Could not persist the notes operation",
+				...error.toolCallId === void 0 ? {} : { toolCallId: error.toolCallId }
+			}))))
+		});
+	}));
+};
+//#endregion
+export { MemoryNotesError, NotesSnapshot, ReadNotes, WriteNotes, layer, MemoryNotes_exports as t, toolkit };
+
+//# sourceMappingURL=MemoryNotes.mjs.map

package/dist/capabilities/MemoryNotes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryNotes.mjs","names":[],"sources":["../../src/capabilities/MemoryNotes.ts"],"sourcesContent":["import { Clock, Effect, Schema } from \"effect\";\nimport { IdGenerator, Tool, Toolkit } from \"effect/unstable/ai\";\n\nimport { utf8ByteLength } from \"../core/internal/utf8.ts\";\nimport { MemoryContent, MemorySourceReference } from \"../core/MemoryReference.ts\";\nimport {\n  ActiveMemoryDocument,\n  MemoryConflict,\n  MemoryDocument,\n  MemoryKey,\n  MemoryMutationFailure,\n  MemoryOperationConflict,\n  MemoryReader,\n  MemoryStorageError,\n  MemoryWithdrawn,\n  MemoryWrite,\n  MemoryWriter,\n} from \"../core/MemoryStore.ts\";\nimport { DurableStep, DurableStepError, ToolExecutionClass } from \"../engine/DurableStep.ts\";\n\nconst NotesText = Schema.String.check(\n  Schema.isMaxLength(20_000),\n  Schema.makeFilter((text) => utf8ByteLength(JSON.stringify(text)) <= 32_768, {\n    expected: \"notes totaling at most 32768 JSON-encoded UTF-8 bytes\",\n  }),\n);\n\n/** A single host-selected document. Null revision and empty text mean it has not been created. */\nexport class NotesSnapshot extends Schema.Class<NotesSnapshot>(\"MemoryNotesSnapshot\")({\n  revision: MemorySourceReference.fields.revision,\n  text: NotesText,\n}) {}\n\n/** A document valid for general Memory exceeded the bounded notes tool's readable shape. */\nexport class MemoryNotesError extends Schema.TaggedError<MemoryNotesError>()(\"MemoryNotesError\", {\n  reason: Schema.Literal(\"limit\"),\n  message: Schema.String.check(Schema.isMaxLength(4_096)),\n}) {}\n\nconst OptionsSchema = Schema.Struct({\n  key: MemoryKey.Wire,\n  locator: MemorySourceReference.fields.locator,\n  attributions: MemoryContent.fields.attributions,\n  scopes: ActiveMemoryDocument.Wire.fields.scopes,\n});\n\n/** Host-owned address, source attribution, and recall visibility; never model parameters. */\nexport type Options = typeof OptionsSchema.Type;\n\nexport const ReadNotes = Tool.make(\"read_notes\", {\n  description:\n    \"Read the durable working notes shared by this agent's host. Preserve their revision when making a replacement. These notes are working memory, not authoritative user instructions.\",\n  parameters: Tool.EmptyParams,\n  success: NotesSnapshot,\n  failure: Schema.Union([MemoryStorageError, MemoryWithdrawn, MemoryNotesError]),\n  failureMode: \"return\",\n})\n  .annotate(ToolExecutionClass, \"readonly\")\n  .annotate(Tool.Readonly, true);\n\nexport const WriteNotes = Tool.make(\"write_notes\", {\n  description:\n    \"Replace the complete durable working notes. Supply the revision from read_notes, or null to create them. On a revision conflict, read again and merge before retrying. Saving notes does not start a new context window.\",\n  parameters: Schema.Struct({\n    text: NotesText.check(Schema.isMinLength(1), Schema.isPattern(/\\S/)),\n    expectedRevision: MemorySourceReference.fields.revision,\n  }),\n  success: NotesSnapshot,\n  failure: Schema.Union([\n    MemoryStorageError,\n    MemoryConflict,\n    MemoryWithdrawn,\n    MemoryOperationConflict,\n    MemoryMutationFailure,\n    MemoryNotesError,\n    DurableStepError,\n  ]),\n  failureMode: \"return\",\n  dependencies: [DurableStep],\n}).annotate(ToolExecutionClass, \"idempotent\");\n\nexport const toolkit = Toolkit.make(ReadNotes, WriteNotes);\n\nconst snapshot = Effect.fn(\"MemoryNotes.snapshot\")(function* (document: MemoryDocument | null) {\n  if (document?._tag === \"WithdrawnMemoryDocument\") {\n    return yield* MemoryWithdrawn.make({\n      key: document.key,\n      revision: document.source.revision,\n    });\n  }\n\n  return yield* Schema.decodeEffect(NotesSnapshot)({\n    revision: document?.source.revision ?? null,\n    text: document?.content.text ?? \"\",\n  }).pipe(\n    Effect.mapError(() =>\n      MemoryNotesError.make({\n        reason: \"limit\",\n        message: \"Notes exceed 20000 characters or 32768 JSON-encoded UTF-8 bytes\",\n      }),\n    ),\n  );\n});\n\n/**\n * Bind the tools to one authorized Memory document. The host supplies a durable MemoryWriter\n * when notes must survive process loss. Revision conflicts never trigger an automatic overwrite.\n * A Durable Step saves the exact command, including operation identity and timestamp, before\n * dispatch; retries reuse it and the writer's existing idempotency receipt. Ephemeral Runs\n * retain the Memory store's semantics but do not acquire durable Tool recovery.\n * Supply Effect AI's IdGenerator service to select operation identities.\n */\nexport const layer = (options: Options) => {\n  const config = Schema.decodeSync(OptionsSchema)(options);\n\n  return toolkit.toLayer(\n    Effect.gen(function* () {\n      const reader = yield* MemoryReader;\n      const writer = yield* MemoryWriter;\n      const ids = yield* IdGenerator.IdGenerator;\n\n      return toolkit.of({\n        read_notes: () => reader.get(config.key).pipe(Effect.flatMap(snapshot)),\n        write_notes: Effect.fn(\"MemoryNotes.write_notes\")(\n          function* (request) {\n            const step = yield* DurableStep;\n\n            const command = yield* step.do(\n              \"prepare-notes\",\n              MemoryWrite.Wire,\n              Effect.gen(function* () {\n                const operationId = yield* ids.generateId();\n                const recordedAt = yield* Clock.currentTimeMillis;\n\n                return MemoryWrite.make({\n                  _tag: \"Put\",\n                  key: config.key,\n                  operationId,\n                  expectedRevision: request.expectedRevision,\n                  locator: config.locator,\n                  scopes: config.scopes,\n                  content: MemoryContent.make({\n                    text: request.text,\n                    attributions: config.attributions,\n                    metadata: {},\n                    recordedAt,\n                  }),\n                });\n              }),\n            );\n\n            const document = yield* step.do(\n              \"write-notes\",\n              MemoryDocument.Wire,\n              writer.change(command),\n            );\n\n            return yield* snapshot(document);\n          },\n          Effect.catchTag(\"DurableStepError\", (error) =>\n            Effect.fail(\n              DurableStepError.make({\n                stepName: error.stepName,\n                reason: error.reason,\n                message: \"Could not persist the notes operation\",\n                ...(error.toolCallId === undefined ? {} : { toolCallId: error.toolCallId }),\n              }),\n            ),\n          ),\n        ),\n      });\n    }),\n  );\n};\n"],"mappings":"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"}

package/dist/capabilities/Messaging.d.mts

@@ -0,0 +1,3 @@
+import { a as MessageAdmission, c as MessageRef, i as MessageAddress, l as MessageStatus, n as InboxPage, o as MessagingError, r as InputMessage, s as PeerName, t as InboxEntry } from "../Messaging-Dkg87ebg.mjs";
+import { a as inspect, c as reply, d as retryTool, f as send, i as inboxTool, l as replyTool, n as Peer, o as inspectTool, p as sendTool, r as inbox, s as peer, u as retry } from "../Messaging-JYYN3oYS.mjs";
+export { InboxEntry, InboxPage, InputMessage, MessageAddress, MessageAdmission, MessageRef, MessageStatus, MessagingError, Peer, PeerName, inbox, inboxTool, inspect, inspectTool, peer, reply, replyTool, retry, retryTool, send, sendTool };

package/dist/capabilities/Messaging.mjs

@@ -0,0 +1,152 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { IdempotencyKey } from "../core/Receipt.mjs";
+import { WorkerOperationTool } from "../core/SubagentContract.mjs";
+import { C as MessageStatus, S as MessageRef } from "../Worker-CfwzMZEK.mjs";
+import { c as InboxPage, d as MessageAdmission, f as MessagingError, l as InputMessage, p as PeerName, s as InboxEntry, t as MessagingHost, u as MessageAddress } from "../MessagingHost-DfsbMPvq.mjs";
+import { t as utf8Bytes } from "../utf8-BYfhEkcj.mjs";
+import { Tool, Toolkit } from "effect/unstable/ai";
+import { Crypto, Effect, Encoding, Option, Schema } from "effect";
+//#region src/capabilities/Messaging.ts
+var Messaging_exports = /* @__PURE__ */ __exportAll({
+	InboxEntry: () => InboxEntry,
+	InboxPage: () => InboxPage,
+	InputMessage: () => InputMessage,
+	MessageAddress: () => MessageAddress,
+	MessageAdmission: () => MessageAdmission,
+	MessageRef: () => MessageRef,
+	MessageStatus: () => MessageStatus,
+	MessagingError: () => MessagingError,
+	PeerName: () => PeerName,
+	inbox: () => inbox,
+	inboxTool: () => inboxTool,
+	inspect: () => inspect,
+	inspectTool: () => inspectTool,
+	peer: () => peer,
+	reply: () => reply,
+	replyTool: () => replyTool,
+	retry: () => retry,
+	retryTool: () => retryTool,
+	send: () => send,
+	sendTool: () => sendTool
+});
+const peer = (name, options) => {
+	Schema.decodeSync(PeerName)(name);
+	return Object.freeze({
+		name,
+		target: options.target
+	});
+};
+const host = Effect.serviceOption(MessagingHost).pipe(Effect.flatMap((value) => Option.isSome(value) ? Effect.succeed(value.value) : MessagingError.make({
+	operation: "context",
+	reason: "unavailable"
+})));
+const dispatch = (declaration, input, options, operation) => Effect.gen(function* () {
+	const service = yield* host;
+	const invalid = () => MessagingError.make({
+		operation,
+		reason: "invalid-input"
+	});
+	const idempotencyKey = yield* Schema.decodeEffect(IdempotencyKey)(options.idempotencyKey).pipe(Effect.mapError(invalid));
+	const encodedInput = yield* Schema.encodeEffect(declaration.target.input)(input).pipe(Effect.mapError(invalid));
+	const inReplyTo = options.inReplyTo === void 0 ? void 0 : yield* Schema.decodeEffect(MessageRef)(options.inReplyTo).pipe(Effect.mapError(invalid));
+	const request = {
+		...declaration,
+		encodedInput,
+		idempotencyKey,
+		...inReplyTo === void 0 ? {} : { inReplyTo }
+	};
+	const result = operation === "reply" ? inReplyTo === void 0 ? yield* invalid() : yield* service.reply({
+		...request,
+		inReplyTo
+	}) : yield* service.send(request);
+	return yield* Schema.decodeEffect(MessageStatus)(result).pipe(Effect.mapError(() => MessagingError.make({
+		operation,
+		reason: "corrupt"
+	})));
+});
+/** Retain a durable message. Its status distinguishes outbound retention from destination acceptance. */
+const send = (declaration, input, options) => dispatch(declaration, input, options, "send");
+/** Reply to an authenticated inbound message; return routing still requires independent send authority. */
+const reply = (declaration, inReplyTo, input, options) => dispatch(declaration, input, {
+	...options,
+	inReplyTo
+}, "reply");
+/** Return bounded provenance for messages from this peer, without granting permission to reply. */
+const inbox = (declaration, options = {}) => Effect.gen(function* () {
+	return yield* (yield* host).inbox({
+		...declaration,
+		...options,
+		limit: options.limit ?? 20
+	});
+});
+const inspect = (declaration, message) => Effect.gen(function* () {
+	return yield* (yield* host).inspect({
+		...declaration,
+		message
+	});
+});
+/** Explicitly renew a parked delivery's bounded retry budget, retaining its complete frozen envelope. */
+const retry = (declaration, message) => Effect.gen(function* () {
+	return yield* (yield* host).retry({
+		...declaration,
+		message
+	});
+});
+const modelKey = Effect.fn("Messaging.modelKey")(function* () {
+	const source = yield* (yield* host).context;
+	if (source._tag !== "tool") return yield* MessagingError.make({
+		operation: "send",
+		reason: "denied"
+	});
+	const digest = yield* (yield* Crypto.Crypto).digest("SHA-256", utf8Bytes(JSON.stringify(source))).pipe(Effect.mapError(() => MessagingError.make({
+		operation: "send",
+		reason: "unavailable"
+	})));
+	return Schema.decodeSync(IdempotencyKey)(`peer-tool:${Encoding.encodeHex(digest)}`);
+});
+const native = (name, parameters, success, description, handler) => {
+	const tool = Tool.make(name, {
+		parameters,
+		success,
+		failure: MessagingError,
+		description
+	}).annotate(WorkerOperationTool, true).addDependency(MessagingHost).addDependency(Crypto.Crypto);
+	const toolkit = Toolkit.make(tool);
+	const build = Effect.gen(function* () {
+		const captured = yield* Effect.context();
+		const invoke = Effect.fn("Messaging.tool")(function* (value) {
+			const service = yield* host;
+			const crypto = yield* Crypto.Crypto;
+			return yield* handler(value).pipe(Effect.provideService(MessagingHost, service), Effect.provideService(Crypto.Crypto, crypto), Effect.provide(captured));
+		});
+		return { [name]: invoke };
+	});
+	return {
+		tool,
+		toolkit,
+		layer: toolkit.toLayer(build)
+	};
+};
+/** Install only the native operations chosen by the host; schemas come from the Peer declaration. */
+const sendTool = (declaration) => native(`${declaration.name}_send`, declaration.target.input, MessageStatus, `Send input to ${declaration.name} through its authorized durable route.`, (input) => Effect.gen(function* () {
+	return yield* send(declaration, input, { idempotencyKey: yield* modelKey() });
+}));
+const replyTool = (declaration) => {
+	const inputSchema = declaration.target.input;
+	return native(`${declaration.name}_reply`, Schema.Struct({
+		inReplyTo: MessageRef,
+		input: inputSchema
+	}), MessageStatus, `Reply to a recorded inbound message from ${declaration.name}.`, ({ inReplyTo, input }) => Effect.gen(function* () {
+		return yield* reply(declaration, inReplyTo, input, { idempotencyKey: yield* modelKey() });
+	}));
+};
+const inboxTool = (declaration) => native(`${declaration.name}_inbox`, Schema.Struct({
+	after: Schema.optionalKey(Schema.Natural),
+	limit: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)))
+}), InboxPage, `Read a bounded page of message provenance from ${declaration.name}.`, (options) => inbox(declaration, options));
+const inspectTool = (declaration) => native(`${declaration.name}_message_status`, Schema.Struct({ message: MessageRef }), MessageStatus, `Inspect delivery status of a message sent to ${declaration.name}.`, ({ message }) => inspect(declaration, message));
+const retryTool = (declaration) => native(`${declaration.name}_retry_message`, Schema.Struct({ message: MessageRef }), MessageStatus, `Renew bounded automatic retries for a parked message to ${declaration.name}.`, ({ message }) => retry(declaration, message));
+//#endregion
+export { InboxEntry, InboxPage, InputMessage, MessageAddress, MessageAdmission, MessageRef, MessageStatus, MessagingError, PeerName, inbox, inboxTool, inspect, inspectTool, peer, reply, replyTool, retry, retryTool, send, sendTool, Messaging_exports as t };
+
+//# sourceMappingURL=Messaging.mjs.map

package/dist/capabilities/Messaging.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Messaging.mjs","names":[],"sources":["../../src/capabilities/Messaging.ts"],"sourcesContent":["import { Crypto, Effect, Encoding, Option, Schema } from \"effect\";\nimport { Tool, Toolkit } from \"effect/unstable/ai\";\n\nimport type { AnyDefinition } from \"../core/Agent.ts\";\nimport {\n  InboxPage,\n  MessageRef,\n  MessageStatus,\n  MessagingError,\n  PeerName,\n} from \"../core/Messaging.ts\";\nimport { IdempotencyKey } from \"../core/Receipt.ts\";\nimport { WorkerOperationTool } from \"../core/SubagentContract.ts\";\nimport { MessagingHost } from \"../engine/MessagingHost.ts\";\nimport { utf8Bytes } from \"./internal/utf8.ts\";\n\nexport * from \"../core/Messaging.ts\";\n\n/** A fixed host route and its destination-owned input Schema. Construction acquires no resources. */\nexport interface Peer<Name extends string, Input extends Schema.Top> {\n  readonly name: Name;\n  readonly target: AnyDefinition & { readonly input: Input };\n}\n\nexport const peer = <const Name extends string, Input extends Schema.Top>(\n  name: Name,\n  options: { readonly target: AnyDefinition & { readonly input: Input } },\n): Peer<Name, Input> => {\n  Schema.decodeSync(PeerName)(name);\n\n  return Object.freeze({ name, target: options.target });\n};\n\nconst host: Effect.Effect<MessagingHost[\"Service\"], MessagingError, MessagingHost> =\n  Effect.serviceOption(MessagingHost).pipe(\n    Effect.flatMap((value) =>\n      Option.isSome(value)\n        ? Effect.succeed(value.value)\n        : MessagingError.make({ operation: \"context\", reason: \"unavailable\" }),\n    ),\n  );\n\nconst dispatch = <Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n  input: Input[\"Type\"],\n  options: { readonly idempotencyKey: IdempotencyKey; readonly inReplyTo?: MessageRef },\n  operation: \"send\" | \"reply\",\n) =>\n  Effect.gen(function* () {\n    const service = yield* host;\n    const invalid = () => MessagingError.make({ operation, reason: \"invalid-input\" });\n\n    const idempotencyKey = yield* Schema.decodeEffect(IdempotencyKey)(options.idempotencyKey).pipe(\n      Effect.mapError(invalid),\n    );\n\n    const encodedInput = yield* Schema.encodeEffect(declaration.target.input)(input).pipe(\n      Effect.mapError(invalid),\n    );\n\n    const inReplyTo =\n      options.inReplyTo === undefined\n        ? undefined\n        : yield* Schema.decodeEffect(MessageRef)(options.inReplyTo).pipe(Effect.mapError(invalid));\n\n    const request = {\n      ...declaration,\n      encodedInput,\n      idempotencyKey,\n      ...(inReplyTo === undefined ? {} : { inReplyTo }),\n    };\n\n    const result =\n      operation === \"reply\"\n        ? inReplyTo === undefined\n          ? yield* invalid()\n          : yield* service.reply({ ...request, inReplyTo })\n        : yield* service.send(request);\n\n    return yield* Schema.decodeEffect(MessageStatus)(result).pipe(\n      Effect.mapError(() => MessagingError.make({ operation, reason: \"corrupt\" })),\n    );\n  });\n\n/** Retain a durable message. Its status distinguishes outbound retention from destination acceptance. */\nexport const send = <Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n  input: Input[\"Type\"],\n  options: { readonly idempotencyKey: IdempotencyKey; readonly inReplyTo?: MessageRef },\n) => dispatch(declaration, input, options, \"send\");\n\n/** Reply to an authenticated inbound message; return routing still requires independent send authority. */\nexport const reply = <Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n  inReplyTo: MessageRef,\n  input: Input[\"Type\"],\n  options: { readonly idempotencyKey: IdempotencyKey },\n) => dispatch(declaration, input, { ...options, inReplyTo }, \"reply\");\n\n/** Return bounded provenance for messages from this peer, without granting permission to reply. */\nexport const inbox = <Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n  options: { readonly after?: number; readonly limit?: number } = {},\n) =>\n  Effect.gen(function* () {\n    const service = yield* host;\n\n    return yield* service.inbox({ ...declaration, ...options, limit: options.limit ?? 20 });\n  });\n\nexport const inspect = <Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n  message: MessageRef,\n) =>\n  Effect.gen(function* () {\n    const service = yield* host;\n\n    return yield* service.inspect({ ...declaration, message });\n  });\n\n/** Explicitly renew a parked delivery's bounded retry budget, retaining its complete frozen envelope. */\nexport const retry = <Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n  message: MessageRef,\n) =>\n  Effect.gen(function* () {\n    const service = yield* host;\n\n    return yield* service.retry({ ...declaration, message });\n  });\n\nconst modelKey = Effect.fn(\"Messaging.modelKey\")(function* () {\n  const source = yield* (yield* host).context;\n\n  if (source._tag !== \"tool\")\n    return yield* MessagingError.make({ operation: \"send\", reason: \"denied\" });\n  const crypto = yield* Crypto.Crypto;\n\n  const digest = yield* crypto\n    .digest(\"SHA-256\", utf8Bytes(JSON.stringify(source)))\n    .pipe(Effect.mapError(() => MessagingError.make({ operation: \"send\", reason: \"unavailable\" })));\n\n  return Schema.decodeSync(IdempotencyKey)(`peer-tool:${Encoding.encodeHex(digest)}`);\n});\n\nconst native = <\n  const Name extends string,\n  Parameters extends Schema.Top,\n  Success extends Schema.Top,\n  R,\n>(\n  name: Name,\n  parameters: Parameters,\n  success: Success,\n  description: string,\n  handler: (\n    parameters: Parameters[\"Type\"],\n  ) => Effect.Effect<Success[\"Type\"], MessagingError, R | MessagingHost | Crypto.Crypto>,\n) => {\n  const tool = Tool.make(name, { parameters, success, failure: MessagingError, description })\n    .annotate(WorkerOperationTool, true)\n    .addDependency(MessagingHost)\n    .addDependency(Crypto.Crypto);\n\n  const toolkit = Toolkit.make(tool);\n\n  const build = Effect.gen(function* () {\n    const captured = yield* Effect.context<Exclude<R, MessagingHost | Crypto.Crypto>>();\n\n    const invoke = Effect.fn(\"Messaging.tool\")(function* (value: Parameters[\"Type\"]) {\n      const service = yield* host;\n      const crypto = yield* Crypto.Crypto;\n\n      return yield* handler(value).pipe(\n        Effect.provideService(MessagingHost, service),\n        Effect.provideService(Crypto.Crypto, crypto),\n        Effect.provide(captured),\n      );\n    });\n\n    // The computed single key is precisely the native Tool's literal name.\n    return { [name]: invoke } as unknown as Toolkit.HandlersFrom<typeof toolkit.tools>;\n  });\n\n  return { tool, toolkit, layer: toolkit.toLayer(build) };\n};\n\n/** Install only the native operations chosen by the host; schemas come from the Peer declaration. */\nexport const sendTool = <const Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n) =>\n  native(\n    `${declaration.name}_send` as const,\n    declaration.target.input,\n    MessageStatus,\n    `Send input to ${declaration.name} through its authorized durable route.`,\n    (input) =>\n      Effect.gen(function* () {\n        return yield* send(declaration, input, { idempotencyKey: yield* modelKey() });\n      }),\n  );\n\nexport const replyTool = <const Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n) => {\n  const inputSchema: Schema.Codec<\n    Input[\"Type\"],\n    Input[\"Encoded\"],\n    Input[\"DecodingServices\"],\n    Input[\"EncodingServices\"]\n  > = declaration.target.input;\n\n  return native(\n    `${declaration.name}_reply` as const,\n    Schema.Struct({ inReplyTo: MessageRef, input: inputSchema }),\n    MessageStatus,\n    `Reply to a recorded inbound message from ${declaration.name}.`,\n    ({ inReplyTo, input }) =>\n      Effect.gen(function* () {\n        return yield* reply(declaration, inReplyTo, input, { idempotencyKey: yield* modelKey() });\n      }),\n  );\n};\n\nexport const inboxTool = <const Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n) =>\n  native(\n    `${declaration.name}_inbox` as const,\n    Schema.Struct({\n      after: Schema.optionalKey(Schema.Natural),\n      limit: Schema.optionalKey(\n        Schema.Int.check(Schema.isGreaterThan(0), Schema.isLessThanOrEqualTo(100)),\n      ),\n    }),\n    InboxPage,\n    `Read a bounded page of message provenance from ${declaration.name}.`,\n    (options) => inbox(declaration, options),\n  );\n\nexport const inspectTool = <const Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n) =>\n  native(\n    `${declaration.name}_message_status` as const,\n    Schema.Struct({ message: MessageRef }),\n    MessageStatus,\n    `Inspect delivery status of a message sent to ${declaration.name}.`,\n    ({ message }) => inspect(declaration, message),\n  );\n\nexport const retryTool = <const Name extends string, Input extends Schema.Top>(\n  declaration: Peer<Name, Input>,\n) =>\n  native(\n    `${declaration.name}_retry_message` as const,\n    Schema.Struct({ message: MessageRef }),\n    MessageStatus,\n    `Renew bounded automatic retries for a parked message to ${declaration.name}.`,\n    ({ message }) => retry(declaration, message),\n  );\n"],"mappings":"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"}

package/dist/capabilities/ModelContext.d.mts

@@ -0,0 +1,89 @@
+import { n as Thread } from "../Thread-DOBQ0QUY.mjs";
+import { Crypto, Effect, Schema } from "effect";
+declare namespace ModelContext_d_exports {
+  export { CompactionArtifact, CompactionDigestError, ContextLimitExceeded, ContextTransform, ContextTransformError, InvalidCompactionArtifact, ModelContextMessage, PreparedModelContext, RetainedFact, applyCompaction, digestCompactionSource, prepareModelContext };
+}
+declare const ModelContextMessage_base: Schema.Class<ModelContextMessage, Schema.Struct<{
+  readonly role: Schema.Literals<readonly ["system", "user", "assistant", "tool"]>;
+  readonly content: Schema.String;
+  readonly sourceSequences: Schema.$Array<Schema.Natural>;
+}>, {}>;
+/** A model-context message derived from, but never replacing, source history. */
+export declare class ModelContextMessage extends ModelContextMessage_base {}
+declare const RetainedFact_base: Schema.Class<RetainedFact, Schema.Struct<{
+  readonly fact: Schema.String;
+  readonly sourceSequences: Schema.$Array<Schema.Natural>;
+}>, {}>;
+/** A fact retained explicitly by compaction, independent of the generated prose summary. */
+export declare class RetainedFact extends RetainedFact_base {}
+declare const CompactionArtifact_base: Schema.Class<CompactionArtifact, Schema.Struct<{
+  readonly version: Schema.Literal<1>;
+  readonly threadId: Schema.brand<Schema.NonEmptyString, "@effect-agent/core/ThreadId">;
+  readonly coversFrom: Schema.Natural;
+  readonly coversThrough: Schema.Natural;
+  readonly summary: typeof ModelContextMessage;
+  readonly retainedFacts: Schema.refine<readonly RetainedFact[], Schema.$Array<typeof RetainedFact>>;
+  readonly tokenEstimate: Schema.Natural;
+  readonly sourceDigest: Schema.String;
+  readonly compactorVersion: Schema.NonEmptyString;
+}>, {}>;
+/** Versioned, replayable artifact that covers a prefix or middle range without deleting source. */
+export declare class CompactionArtifact extends CompactionArtifact_base {}
+declare const PreparedModelContext_base: Schema.Class<PreparedModelContext, Schema.Struct<{
+  readonly source: typeof Thread;
+  readonly messages: Schema.refine<readonly ModelContextMessage[], Schema.$Array<typeof ModelContextMessage>>;
+  readonly compactions: Schema.$Array<typeof CompactionArtifact>;
+}>, {}>;
+/** Context exposed to a model, with source history kept intact for audit and reconstruction. */
+export declare class PreparedModelContext extends PreparedModelContext_base {}
+declare const ContextTransformError_base: Schema.Class<ContextTransformError, Schema.TaggedStruct<"ContextTransformError", {
+  readonly transformId: Schema.NonEmptyString;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Transform failure is named and bounded so model context preparation has a closed error channel. */
+export declare class ContextTransformError extends ContextTransformError_base {}
+declare const CompactionDigestError_base: Schema.Class<CompactionDigestError, Schema.TaggedStruct<"CompactionDigestError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Source encoding or hashing failed before an artifact could be trusted. */
+export declare class CompactionDigestError extends CompactionDigestError_base {}
+declare const InvalidCompactionArtifact_base: Schema.Class<InvalidCompactionArtifact, Schema.TaggedStruct<"InvalidCompactionArtifact", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Compaction artifacts that do not bind to the exact source range are rejected before use. */
+export declare class InvalidCompactionArtifact extends InvalidCompactionArtifact_base {}
+declare const ContextLimitExceeded_base: Schema.Class<ContextLimitExceeded, Schema.TaggedStruct<"ContextLimitExceeded", {
+  readonly limit: Schema.Literals<readonly ["messages", "message-bytes", "compactions"]>;
+  readonly limitValue: Schema.Natural;
+  readonly observedValue: Schema.Natural;
+}>, import("effect/Cause").YieldableError>;
+/** A transform or compaction exceeded the finite model-view collection bounds. */
+export declare class ContextLimitExceeded extends ContextLimitExceeded_base {}
+/**
+ * Ordered context transform. It receives and returns only the model-visible
+ * message view, making replacement of the authoritative source impossible.
+ * Required services remain visible in prepareModelContext; expected failures
+ * are translated by the transform into ContextTransformError.
+ */
+export interface ContextTransform<Requirements = never> {
+  readonly id: string;
+  readonly version: string;
+  readonly apply: (messages: ReadonlyArray<ModelContextMessage>) => Effect.Effect<ReadonlyArray<ModelContextMessage>, ContextTransformError, Requirements>;
+}
+/** Apply transforms in declaration order, always restoring the original source snapshot. */
+export declare const prepareModelContext: <const Requirements extends ReadonlyArray<unknown> = readonly []>(snapshot: Thread, transforms?: { readonly [Index in keyof Requirements]: ContextTransform<Requirements[Index]>; }) => Effect.Effect<PreparedModelContext, ContextTransformError, Requirements[number]>;
+/** Compute a cryptographic digest over the canonical encoded exact source range. */
+export declare const digestCompactionSource: (snapshot: Thread, coversFrom: number, coversThrough: number) => Effect.Effect<string, CompactionDigestError | InvalidCompactionArtifact, Crypto.Crypto>;
+/**
+ * Replace only the model-view messages fully covered by the artifact range
+ * with its summary. The digest is recomputed against the exact source slice
+ * before the artifact can influence context. Messages that are not fully
+ * covered — including transform-synthesized messages without provenance and
+ * messages whose provenance only partially overlaps the range — remain
+ * visible, and the summary is inserted before the first message derived
+ * entirely from later source.
+ */
+export declare const applyCompaction: (context: PreparedModelContext, artifact: CompactionArtifact) => Effect.Effect<PreparedModelContext, CompactionDigestError | ContextLimitExceeded | ContextTransformError | InvalidCompactionArtifact, Crypto.Crypto>;
+//#endregion
+export { ModelContext_d_exports as t };
+//# sourceMappingURL=ModelContext.d.mts.map

package/dist/capabilities/ModelContext.mjs

@@ -0,0 +1,168 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ThreadId } from "../core/Identifiers.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { Thread, ThreadMessage, ThreadText } from "../core/Thread.mjs";
+import { Crypto, Effect, Encoding, Schema } from "effect";
+//#region src/capabilities/ModelContext.ts
+var ModelContext_exports = /* @__PURE__ */ __exportAll({
+	CompactionArtifact: () => CompactionArtifact,
+	CompactionDigestError: () => CompactionDigestError,
+	ContextLimitExceeded: () => ContextLimitExceeded,
+	ContextTransformError: () => ContextTransformError,
+	InvalidCompactionArtifact: () => InvalidCompactionArtifact,
+	ModelContextMessage: () => ModelContextMessage,
+	PreparedModelContext: () => PreparedModelContext,
+	RetainedFact: () => RetainedFact,
+	applyCompaction: () => applyCompaction,
+	digestCompactionSource: () => digestCompactionSource,
+	prepareModelContext: () => prepareModelContext
+});
+const MAX_CONTEXT_MESSAGES = 1024;
+const MAX_CONTEXT_MESSAGE_BYTES = 4194304;
+const MAX_SOURCE_SEQUENCES = 1024;
+const MAX_RETAINED_FACTS = 256;
+const MAX_RETAINED_FACT_BYTES = 1048576;
+const MAX_COMPACTIONS = 16;
+const SourceSequences = Schema.Array(Schema.Natural).check(Schema.isMaxLength(MAX_SOURCE_SEQUENCES));
+/** A model-context message derived from, but never replacing, source history. */
+var ModelContextMessage = class extends Schema.Class("@effect-agent/capabilities/ModelContextMessage")({
+	role: Schema.Literals([
+		"system",
+		"user",
+		"assistant",
+		"tool"
+	]),
+	content: ThreadText,
+	sourceSequences: SourceSequences
+}) {};
+/** A fact retained explicitly by compaction, independent of the generated prose summary. */
+var RetainedFact = class extends Schema.Class("@effect-agent/capabilities/RetainedFact")({
+	fact: Schema.String.check(Schema.isMaxLength(4096)),
+	sourceSequences: SourceSequences
+}) {};
+const ModelContextMessages = Schema.Array(ModelContextMessage).check(Schema.isMaxLength(MAX_CONTEXT_MESSAGES)).pipe(Schema.refine((messages) => messages.reduce((total, message) => total + utf8ByteLength(message.content), 0) <= MAX_CONTEXT_MESSAGE_BYTES, { expected: `model context totaling at most ${MAX_CONTEXT_MESSAGE_BYTES} UTF-8 bytes` }));
+const RetainedFacts = Schema.Array(RetainedFact).check(Schema.isMaxLength(MAX_RETAINED_FACTS)).pipe(Schema.refine((facts) => facts.reduce((total, retained) => total + utf8ByteLength(retained.fact), 0) <= MAX_RETAINED_FACT_BYTES, { expected: `retained facts totaling at most ${MAX_RETAINED_FACT_BYTES} UTF-8 bytes` }));
+const SourceDigest = Schema.String.check(Schema.isPattern(/^sha256:[a-f0-9]{64}$/));
+/** Versioned, replayable artifact that covers a prefix or middle range without deleting source. */
+var CompactionArtifact = class extends Schema.Class("@effect-agent/capabilities/CompactionArtifact")({
+	version: Schema.Literal(1),
+	threadId: ThreadId,
+	coversFrom: Schema.Natural,
+	coversThrough: Schema.Natural,
+	summary: ModelContextMessage,
+	retainedFacts: RetainedFacts,
+	tokenEstimate: Schema.Natural,
+	sourceDigest: SourceDigest,
+	compactorVersion: Schema.NonEmptyString
+}) {};
+/** Context exposed to a model, with source history kept intact for audit and reconstruction. */
+var PreparedModelContext = class extends Schema.Class("@effect-agent/capabilities/PreparedModelContext")({
+	source: Thread,
+	messages: ModelContextMessages,
+	compactions: Schema.Array(CompactionArtifact).check(Schema.isMaxLength(MAX_COMPACTIONS))
+}) {};
+/** Transform failure is named and bounded so model context preparation has a closed error channel. */
+var ContextTransformError = class extends Schema.TaggedError()("ContextTransformError", {
+	transformId: Schema.NonEmptyString,
+	message: Schema.String
+}) {};
+/** Source encoding or hashing failed before an artifact could be trusted. */
+var CompactionDigestError = class extends Schema.TaggedError()("CompactionDigestError", { message: Schema.String }) {};
+/** Compaction artifacts that do not bind to the exact source range are rejected before use. */
+var InvalidCompactionArtifact = class extends Schema.TaggedError()("InvalidCompactionArtifact", { message: Schema.String }) {};
+/** A transform or compaction exceeded the finite model-view collection bounds. */
+var ContextLimitExceeded = class extends Schema.TaggedError()("ContextLimitExceeded", {
+	limit: Schema.Literals([
+		"messages",
+		"message-bytes",
+		"compactions"
+	]),
+	limitValue: Schema.Natural,
+	observedValue: Schema.Natural
+}) {};
+const messageText = (message) => {
+	if (message.role === "system") return message.content;
+	return message.content.map((part) => {
+		if (part.type === "text" || part.type === "reasoning") return part.text;
+		return `[${part.type}]`;
+	}).join("\n").slice(0, 65536);
+};
+const asModelMessages = (snapshot) => snapshot.messages.map((entry) => ModelContextMessage.make({
+	role: entry.message.role,
+	content: messageText(entry.message),
+	sourceSequences: [entry.sequence]
+}));
+const validateModelView = (messages, transformId) => {
+	if (messages.length > MAX_CONTEXT_MESSAGES) return Effect.fail(ContextTransformError.make({
+		transformId,
+		message: `Transform produced ${messages.length} messages; maximum is ${MAX_CONTEXT_MESSAGES}`
+	}));
+	const bytes = messages.reduce((total, message) => total + utf8ByteLength(message.content), 0);
+	return bytes > MAX_CONTEXT_MESSAGE_BYTES ? Effect.fail(ContextTransformError.make({
+		transformId,
+		message: `Transform produced ${bytes} UTF-8 bytes; maximum is ${MAX_CONTEXT_MESSAGE_BYTES}`
+	})) : Effect.succeed(messages);
+};
+/** Apply transforms in declaration order, always restoring the original source snapshot. */
+const prepareModelContext = (snapshot, transforms) => (transforms ?? []).reduce((messages, transform) => messages.pipe(Effect.flatMap(transform.apply), Effect.flatMap((transformed) => validateModelView(transformed, transform.id))), Effect.succeed(asModelMessages(snapshot))).pipe(Effect.map((messages) => PreparedModelContext.make({
+	source: snapshot,
+	messages,
+	compactions: []
+})));
+const exactSourceRange = (snapshot, coversFrom, coversThrough) => {
+	if (coversFrom > coversThrough || coversThrough >= snapshot.nextSequence) return Effect.fail(InvalidCompactionArtifact.make({ message: "Compaction artifact covers an invalid source range" }));
+	const selected = snapshot.messages.filter((message) => message.sequence >= coversFrom && message.sequence <= coversThrough);
+	const expectedCount = coversThrough - coversFrom + 1;
+	if (selected.length !== expectedCount || selected[0]?.sequence !== coversFrom || selected[selected.length - 1]?.sequence !== coversThrough) return Effect.fail(InvalidCompactionArtifact.make({ message: "Compaction source range is not contiguous in authoritative history" }));
+	return Effect.succeed(selected);
+};
+const utf8Bytes = (value) => {
+	const hex = Encoding.encodeHex(value);
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let index = 0; index < bytes.length; index += 1) bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+	return bytes;
+};
+/** Compute a cryptographic digest over the canonical encoded exact source range. */
+const digestCompactionSource = Effect.fn("digestCompactionSource")(function* (snapshot, coversFrom, coversThrough) {
+	const selected = yield* exactSourceRange(snapshot, coversFrom, coversThrough);
+	const encoded = yield* Schema.encodeEffect(Schema.Array(ThreadMessage))(selected).pipe(Effect.mapError((error) => CompactionDigestError.make({ message: `Could not encode compaction source: ${error.message}` })));
+	const digest = yield* (yield* Crypto.Crypto).digest("SHA-256", utf8Bytes(JSON.stringify(encoded))).pipe(Effect.mapError((error) => CompactionDigestError.make({ message: `Could not digest compaction source: ${error.message}` })));
+	return `sha256:${Encoding.encodeHex(digest)}`;
+});
+/**
+* Replace only the model-view messages fully covered by the artifact range
+* with its summary. The digest is recomputed against the exact source slice
+* before the artifact can influence context. Messages that are not fully
+* covered — including transform-synthesized messages without provenance and
+* messages whose provenance only partially overlaps the range — remain
+* visible, and the summary is inserted before the first message derived
+* entirely from later source.
+*/
+const applyCompaction = Effect.fn("applyCompaction")(function* (context, artifact) {
+	if (artifact.threadId !== context.source.threadId) return yield* InvalidCompactionArtifact.make({ message: "Compaction artifact belongs to another Thread" });
+	if ((yield* digestCompactionSource(context.source, artifact.coversFrom, artifact.coversThrough)) !== artifact.sourceDigest) return yield* InvalidCompactionArtifact.make({ message: "Compaction source digest does not match authoritative history" });
+	const provenanceInRange = (sequences) => sequences.length > 0 && sequences.every((sequence) => sequence >= artifact.coversFrom && sequence <= artifact.coversThrough);
+	if (!provenanceInRange(artifact.summary.sourceSequences) || artifact.retainedFacts.some((fact) => !provenanceInRange(fact.sourceSequences))) return yield* InvalidCompactionArtifact.make({ message: "Compaction summary or retained-fact provenance falls outside its covered range" });
+	if (context.compactions.length >= MAX_COMPACTIONS) return yield* ContextLimitExceeded.make({
+		limit: "compactions",
+		limitValue: MAX_COMPACTIONS,
+		observedValue: context.compactions.length + 1
+	});
+	const fullyCovered = (message) => message.sourceSequences.length > 0 && message.sourceSequences.every((sequence) => sequence >= artifact.coversFrom && sequence <= artifact.coversThrough);
+	const kept = context.messages.filter((message) => !fullyCovered(message));
+	const summaryAt = kept.findIndex((message) => message.sourceSequences.length > 0 && message.sourceSequences.every((sequence) => sequence > artifact.coversThrough));
+	const messages = yield* validateModelView(summaryAt === -1 ? [...kept, artifact.summary] : [
+		...kept.slice(0, summaryAt),
+		artifact.summary,
+		...kept.slice(summaryAt)
+	], `compaction:${artifact.compactorVersion}`);
+	return PreparedModelContext.make({
+		source: context.source,
+		messages,
+		compactions: [...context.compactions, artifact]
+	});
+});
+//#endregion
+export { CompactionArtifact, CompactionDigestError, ContextLimitExceeded, ContextTransformError, InvalidCompactionArtifact, ModelContextMessage, PreparedModelContext, RetainedFact, applyCompaction, digestCompactionSource, prepareModelContext, ModelContext_exports as t };
+
+//# sourceMappingURL=ModelContext.mjs.map

package/dist/capabilities/ModelContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelContext.mjs","names":["ThreadSnapshot"],"sources":["../../src/capabilities/ModelContext.ts"],"sourcesContent":["import { Crypto, Effect, Encoding, Schema } from \"effect\";\nimport type { Prompt } from \"effect/unstable/ai\";\n\nimport { ThreadId } from \"../core/Identifiers.ts\";\nimport { utf8ByteLength } from \"../core/internal/utf8.ts\";\nimport { ThreadMessage, Thread as ThreadSnapshot, ThreadText } from \"../core/Thread.ts\";\n\nconst MAX_CONTEXT_MESSAGES = 1_024;\nconst MAX_CONTEXT_MESSAGE_BYTES = 4 * 1024 * 1024;\nconst MAX_SOURCE_SEQUENCES = 1_024;\nconst MAX_RETAINED_FACTS = 256;\nconst MAX_RETAINED_FACT_BYTES = 1024 * 1024;\nconst MAX_COMPACTIONS = 16;\n\nconst SourceSequences = Schema.Array(Schema.Natural).check(\n  Schema.isMaxLength(MAX_SOURCE_SEQUENCES),\n);\n\n/** A model-context message derived from, but never replacing, source history. */\nexport class ModelContextMessage extends Schema.Class<ModelContextMessage>(\n  \"@effect-agent/capabilities/ModelContextMessage\",\n)({\n  role: Schema.Literals([\"system\", \"user\", \"assistant\", \"tool\"]),\n  content: ThreadText,\n  sourceSequences: SourceSequences,\n}) {}\n\n/** A fact retained explicitly by compaction, independent of the generated prose summary. */\nexport class RetainedFact extends Schema.Class<RetainedFact>(\n  \"@effect-agent/capabilities/RetainedFact\",\n)({\n  fact: Schema.String.check(Schema.isMaxLength(4 * 1024)),\n  sourceSequences: SourceSequences,\n}) {}\n\nconst ModelContextMessages = Schema.Array(ModelContextMessage)\n  .check(Schema.isMaxLength(MAX_CONTEXT_MESSAGES))\n  .pipe(\n    Schema.refine(\n      (messages): messages is ReadonlyArray<ModelContextMessage> =>\n        messages.reduce((total, message) => total + utf8ByteLength(message.content), 0) <=\n        MAX_CONTEXT_MESSAGE_BYTES,\n      { expected: `model context totaling at most ${MAX_CONTEXT_MESSAGE_BYTES} UTF-8 bytes` },\n    ),\n  );\n\nconst RetainedFacts = Schema.Array(RetainedFact)\n  .check(Schema.isMaxLength(MAX_RETAINED_FACTS))\n  .pipe(\n    Schema.refine(\n      (facts): facts is ReadonlyArray<RetainedFact> =>\n        facts.reduce((total, retained) => total + utf8ByteLength(retained.fact), 0) <=\n        MAX_RETAINED_FACT_BYTES,\n      { expected: `retained facts totaling at most ${MAX_RETAINED_FACT_BYTES} UTF-8 bytes` },\n    ),\n  );\n\nconst SourceDigest = Schema.String.check(Schema.isPattern(/^sha256:[a-f0-9]{64}$/));\n\n/** Versioned, replayable artifact that covers a prefix or middle range without deleting source. */\nexport class CompactionArtifact extends Schema.Class<CompactionArtifact>(\n  \"@effect-agent/capabilities/CompactionArtifact\",\n)({\n  version: Schema.Literal(1),\n  threadId: ThreadId,\n  coversFrom: Schema.Natural,\n  coversThrough: Schema.Natural,\n  summary: ModelContextMessage,\n  retainedFacts: RetainedFacts,\n  tokenEstimate: Schema.Natural,\n  sourceDigest: SourceDigest,\n  compactorVersion: Schema.NonEmptyString,\n}) {}\n\n/** Context exposed to a model, with source history kept intact for audit and reconstruction. */\nexport class PreparedModelContext extends Schema.Class<PreparedModelContext>(\n  \"@effect-agent/capabilities/PreparedModelContext\",\n)({\n  source: ThreadSnapshot,\n  messages: ModelContextMessages,\n  compactions: Schema.Array(CompactionArtifact).check(Schema.isMaxLength(MAX_COMPACTIONS)),\n}) {}\n\n/** Transform failure is named and bounded so model context preparation has a closed error channel. */\nexport class ContextTransformError extends Schema.TaggedError<ContextTransformError>()(\n  \"ContextTransformError\",\n  { transformId: Schema.NonEmptyString, message: Schema.String },\n) {}\n\n/** Source encoding or hashing failed before an artifact could be trusted. */\nexport class CompactionDigestError extends Schema.TaggedError<CompactionDigestError>()(\n  \"CompactionDigestError\",\n  { message: Schema.String },\n) {}\n\n/** Compaction artifacts that do not bind to the exact source range are rejected before use. */\nexport class InvalidCompactionArtifact extends Schema.TaggedError<InvalidCompactionArtifact>()(\n  \"InvalidCompactionArtifact\",\n  { message: Schema.String },\n) {}\n\n/** A transform or compaction exceeded the finite model-view collection bounds. */\nexport class ContextLimitExceeded extends Schema.TaggedError<ContextLimitExceeded>()(\n  \"ContextLimitExceeded\",\n  {\n    limit: Schema.Literals([\"messages\", \"message-bytes\", \"compactions\"]),\n    limitValue: Schema.Natural,\n    observedValue: Schema.Natural,\n  },\n) {}\n\n/**\n * Ordered context transform. It receives and returns only the model-visible\n * message view, making replacement of the authoritative source impossible.\n * Required services remain visible in prepareModelContext; expected failures\n * are translated by the transform into ContextTransformError.\n */\nexport interface ContextTransform<Requirements = never> {\n  readonly id: string;\n  readonly version: string;\n  readonly apply: (\n    messages: ReadonlyArray<ModelContextMessage>,\n  ) => Effect.Effect<ReadonlyArray<ModelContextMessage>, ContextTransformError, Requirements>;\n}\n\nconst messageText = (message: Prompt.Message): string => {\n  if (message.role === \"system\") return message.content;\n\n  const content = message.content\n    .map((part) => {\n      if (part.type === \"text\" || part.type === \"reasoning\") return part.text;\n\n      return `[${part.type}]`;\n    })\n    .join(\"\\n\");\n\n  return content.slice(0, 64 * 1024);\n};\n\nconst asModelMessages = (snapshot: ThreadSnapshot): ReadonlyArray<ModelContextMessage> =>\n  snapshot.messages.map((entry) =>\n    ModelContextMessage.make({\n      role: entry.message.role,\n      content: messageText(entry.message),\n      sourceSequences: [entry.sequence],\n    }),\n  );\n\nconst validateModelView = (\n  messages: ReadonlyArray<ModelContextMessage>,\n  transformId: string,\n): Effect.Effect<ReadonlyArray<ModelContextMessage>, ContextTransformError> => {\n  if (messages.length > MAX_CONTEXT_MESSAGES) {\n    return Effect.fail(\n      ContextTransformError.make({\n        transformId,\n        message: `Transform produced ${messages.length} messages; maximum is ${MAX_CONTEXT_MESSAGES}`,\n      }),\n    );\n  }\n  const bytes = messages.reduce((total, message) => total + utf8ByteLength(message.content), 0);\n\n  return bytes > MAX_CONTEXT_MESSAGE_BYTES\n    ? Effect.fail(\n        ContextTransformError.make({\n          transformId,\n          message: `Transform produced ${bytes} UTF-8 bytes; maximum is ${MAX_CONTEXT_MESSAGE_BYTES}`,\n        }),\n      )\n    : Effect.succeed(messages);\n};\n\n/** Apply transforms in declaration order, always restoring the original source snapshot. */\nexport const prepareModelContext = <\n  const Requirements extends ReadonlyArray<unknown> = readonly [],\n>(\n  snapshot: ThreadSnapshot,\n  transforms?: { readonly [Index in keyof Requirements]: ContextTransform<Requirements[Index]> },\n): Effect.Effect<PreparedModelContext, ContextTransformError, Requirements[number]> =>\n  (transforms ?? [])\n    .reduce<\n      Effect.Effect<ReadonlyArray<ModelContextMessage>, ContextTransformError, Requirements[number]>\n    >(\n      (messages, transform) =>\n        messages.pipe(\n          Effect.flatMap(transform.apply),\n          Effect.flatMap((transformed) => validateModelView(transformed, transform.id)),\n        ),\n      Effect.succeed(asModelMessages(snapshot)),\n    )\n    .pipe(\n      Effect.map((messages) =>\n        PreparedModelContext.make({\n          source: snapshot,\n          messages,\n          compactions: [],\n        }),\n      ),\n    );\n\nconst exactSourceRange = (\n  snapshot: ThreadSnapshot,\n  coversFrom: number,\n  coversThrough: number,\n): Effect.Effect<ReadonlyArray<ThreadMessage>, InvalidCompactionArtifact> => {\n  if (coversFrom > coversThrough || coversThrough >= snapshot.nextSequence) {\n    return Effect.fail(\n      InvalidCompactionArtifact.make({\n        message: \"Compaction artifact covers an invalid source range\",\n      }),\n    );\n  }\n\n  const selected = snapshot.messages.filter(\n    (message) => message.sequence >= coversFrom && message.sequence <= coversThrough,\n  );\n\n  const expectedCount = coversThrough - coversFrom + 1;\n\n  if (\n    selected.length !== expectedCount ||\n    selected[0]?.sequence !== coversFrom ||\n    selected[selected.length - 1]?.sequence !== coversThrough\n  ) {\n    return Effect.fail(\n      InvalidCompactionArtifact.make({\n        message: \"Compaction source range is not contiguous in authoritative history\",\n      }),\n    );\n  }\n\n  return Effect.succeed(selected);\n};\n\nconst utf8Bytes = (value: string): Uint8Array => {\n  const hex = Encoding.encodeHex(value);\n  const bytes = new Uint8Array(hex.length / 2);\n\n  for (let index = 0; index < bytes.length; index += 1) {\n    bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);\n  }\n\n  return bytes;\n};\n\n/** Compute a cryptographic digest over the canonical encoded exact source range. */\nexport const digestCompactionSource = Effect.fn(\"digestCompactionSource\")(function* (\n  snapshot: ThreadSnapshot,\n  coversFrom: number,\n  coversThrough: number,\n) {\n  const selected = yield* exactSourceRange(snapshot, coversFrom, coversThrough);\n\n  const encoded = yield* Schema.encodeEffect(Schema.Array(ThreadMessage))(selected).pipe(\n    Effect.mapError((error) =>\n      CompactionDigestError.make({\n        message: `Could not encode compaction source: ${error.message}`,\n      }),\n    ),\n  );\n\n  const crypto = yield* Crypto.Crypto;\n\n  const digest = yield* crypto.digest(\"SHA-256\", utf8Bytes(JSON.stringify(encoded))).pipe(\n    Effect.mapError((error) =>\n      CompactionDigestError.make({\n        message: `Could not digest compaction source: ${error.message}`,\n      }),\n    ),\n  );\n\n  return `sha256:${Encoding.encodeHex(digest)}`;\n});\n\n/**\n * Replace only the model-view messages fully covered by the artifact range\n * with its summary. The digest is recomputed against the exact source slice\n * before the artifact can influence context. Messages that are not fully\n * covered — including transform-synthesized messages without provenance and\n * messages whose provenance only partially overlaps the range — remain\n * visible, and the summary is inserted before the first message derived\n * entirely from later source.\n */\nexport const applyCompaction = Effect.fn(\"applyCompaction\")(function* (\n  context: PreparedModelContext,\n  artifact: CompactionArtifact,\n) {\n  if (artifact.threadId !== context.source.threadId) {\n    return yield* InvalidCompactionArtifact.make({\n      message: \"Compaction artifact belongs to another Thread\",\n    });\n  }\n\n  const actualDigest = yield* digestCompactionSource(\n    context.source,\n    artifact.coversFrom,\n    artifact.coversThrough,\n  );\n\n  if (actualDigest !== artifact.sourceDigest) {\n    return yield* InvalidCompactionArtifact.make({\n      message: \"Compaction source digest does not match authoritative history\",\n    });\n  }\n\n  const provenanceInRange = (sequences: ReadonlyArray<number>): boolean =>\n    sequences.length > 0 &&\n    sequences.every(\n      (sequence) => sequence >= artifact.coversFrom && sequence <= artifact.coversThrough,\n    );\n\n  if (\n    !provenanceInRange(artifact.summary.sourceSequences) ||\n    artifact.retainedFacts.some((fact) => !provenanceInRange(fact.sourceSequences))\n  ) {\n    return yield* InvalidCompactionArtifact.make({\n      message: \"Compaction summary or retained-fact provenance falls outside its covered range\",\n    });\n  }\n  if (context.compactions.length >= MAX_COMPACTIONS) {\n    return yield* ContextLimitExceeded.make({\n      limit: \"compactions\",\n      limitValue: MAX_COMPACTIONS,\n      observedValue: context.compactions.length + 1,\n    });\n  }\n\n  const fullyCovered = (message: ModelContextMessage): boolean =>\n    message.sourceSequences.length > 0 &&\n    message.sourceSequences.every(\n      (sequence) => sequence >= artifact.coversFrom && sequence <= artifact.coversThrough,\n    );\n\n  const kept = context.messages.filter((message) => !fullyCovered(message));\n\n  const summaryAt = kept.findIndex(\n    (message) =>\n      message.sourceSequences.length > 0 &&\n      message.sourceSequences.every((sequence) => sequence > artifact.coversThrough),\n  );\n\n  const messages = yield* validateModelView(\n    summaryAt === -1\n      ? [...kept, artifact.summary]\n      : [...kept.slice(0, summaryAt), artifact.summary, ...kept.slice(summaryAt)],\n    `compaction:${artifact.compactorVersion}`,\n  );\n\n  return PreparedModelContext.make({\n    source: context.source,\n    messages,\n    compactions: [...context.compactions, artifact],\n  });\n});\n"],"mappings":"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"}