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

package/dist/capabilities/Messaging.mjs

@@ -0,0 +1,151 @@
+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 InboxPage, d as MessageAdmission, f as MessageRef, h as PeerName, l as InputMessage, m as MessagingError, p as MessageStatus, s as InboxEntry, t as MessagingHost, u as MessageAddress } from "../MessagingHost-CWi_PP3g.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. */
+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. */
+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. */
+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. */
+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. */
+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. */
+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. */
+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. */
+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.
+ */
+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. */
+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. */
+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.
+ */
+declare const applyCompaction: (context: PreparedModelContext, artifact: CompactionArtifact) => Effect.Effect<PreparedModelContext, CompactionDigestError | ContextLimitExceeded | ContextTransformError | InvalidCompactionArtifact, Crypto.Crypto>;
+//#endregion
+export { CompactionArtifact, CompactionDigestError, ContextLimitExceeded, ContextTransform, ContextTransformError, InvalidCompactionArtifact, ModelContextMessage, PreparedModelContext, RetainedFact, applyCompaction, digestCompactionSource, prepareModelContext, 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 { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { ThreadId } from "../core/Identifiers.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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"}

package/dist/capabilities/Redaction.d.mts

@@ -0,0 +1,37 @@
+import { l as RunEvent } from "../RunEvent-DIrzkjLr.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+declare namespace Redaction_d_exports {
+  export { RedactedPreview, RedactionError, Redactor, StructuralRedactorLive, redactedTranscript };
+}
+/** Branded evidence that a preview passed through the configured structural Redactor. */
+declare const RedactedPreview: Schema.brand<Schema.refine<string, Schema.String>, "@effect-agent/capabilities/RedactedPreview">;
+type RedactedPreview = typeof RedactedPreview.Type;
+declare const RedactionError_base: Schema.Class<RedactionError, Schema.TaggedStruct<"RedactionError", {
+  readonly reason: Schema.Literals<readonly ["input-too-deep", "input-too-large", "encoding-failed"]>;
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Structural redaction failed closed rather than returning unreviewed caller text. */
+declare class RedactionError extends RedactionError_base {}
+declare const Redactor_base: Context.ServiceClass<Redactor, "@effect-agent/capabilities/Redactor", {
+  readonly redact: (decodedValue: unknown) => Effect.Effect<RedactedPreview, RedactionError>;
+}>;
+/** Redaction owns the boundary from decoded Tool values to bounded audit/model previews. */
+declare class Redactor extends Redactor_base {}
+/**
+ * One composed step from live Run Events to structurally redacted transcript lines
+ * (P7 WP7 friction fix; SEC-008/testing.md §12 "structurally redacted" live transcripts):
+ * Schema-encode each event through the canonical `RunEvent` union, then pass the encoded
+ * value through the configured `Redactor` — so the safe path is the short path and no live
+ * suite hand-assembles (or accidentally skips) the encode→redact pair. Engine-constructed
+ * events always encode, so an encode failure is a defect, never a silent omission.
+ */
+declare const redactedTranscript: (events: Iterable<RunEvent>) => Effect.Effect<ReadonlyArray<RedactedPreview>, RedactionError, Redactor>;
+/**
+ * Default structural implementation. It exposes only collection shape and
+ * scalar types, so an ordinary field such as `note` cannot bypass redaction.
+ * Tool-specific Layers may expose explicitly reviewed fields instead.
+ */
+declare const StructuralRedactorLive: Layer.Layer<Redactor, never, never>;
+//#endregion
+export { RedactedPreview, RedactionError, Redactor, StructuralRedactorLive, redactedTranscript, Redaction_d_exports as t };
+//# sourceMappingURL=Redaction.d.mts.map

package/dist/capabilities/Redaction.mjs

@@ -0,0 +1,104 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { RunEvent } from "../core/RunEvent.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/capabilities/Redaction.ts
+var Redaction_exports = /* @__PURE__ */ __exportAll({
+	RedactedPreview: () => RedactedPreview,
+	RedactionError: () => RedactionError,
+	Redactor: () => Redactor,
+	StructuralRedactorLive: () => StructuralRedactorLive,
+	redactedTranscript: () => redactedTranscript
+});
+const MAX_REDACTED_PREVIEW_BYTES = 8192;
+const MAX_REDACTION_NODES = 4096;
+const MAX_REDACTION_DEPTH = 16;
+/** Branded evidence that a preview passed through the configured structural Redactor. */
+const RedactedPreview = Schema.String.pipe(Schema.refine((value) => utf8ByteLength(value) <= MAX_REDACTED_PREVIEW_BYTES, { expected: `redacted preview of at most ${MAX_REDACTED_PREVIEW_BYTES} UTF-8 bytes` }), Schema.brand("@effect-agent/capabilities/RedactedPreview"));
+/** Structural redaction failed closed rather than returning unreviewed caller text. */
+var RedactionError = class extends Schema.TaggedError()("RedactionError", {
+	reason: Schema.Literals([
+		"input-too-deep",
+		"input-too-large",
+		"encoding-failed"
+	]),
+	message: Schema.String
+}) {};
+/** Redaction owns the boundary from decoded Tool values to bounded audit/model previews. */
+var Redactor = class extends Context.Service()("@effect-agent/capabilities/Redactor") {};
+const redactValue = (value, depth, counter) => {
+	if (depth > MAX_REDACTION_DEPTH) throw RedactionError.make({
+		reason: "input-too-deep",
+		message: `Decoded value exceeds redaction depth ${MAX_REDACTION_DEPTH}`
+	});
+	counter.nodes += 1;
+	if (counter.nodes > MAX_REDACTION_NODES) throw RedactionError.make({
+		reason: "input-too-large",
+		message: `Decoded value exceeds redaction node count ${MAX_REDACTION_NODES}`
+	});
+	if (Array.isArray(value)) return value.map((item) => redactValue(item, depth + 1, counter));
+	if (value !== null && typeof value === "object") {
+		const redacted = {};
+		for (const [key, item] of Object.entries(value)) redacted[key] = redactValue(item, depth + 1, counter);
+		return redacted;
+	}
+	if (value === null) return "[REDACTED:null]";
+	if (typeof value === "string") return "[REDACTED:string]";
+	if (typeof value === "number") return "[REDACTED:number]";
+	if (typeof value === "boolean") return "[REDACTED:boolean]";
+	return "[REDACTED:unsupported]";
+};
+const truncateUtf8 = (value, maxBytes) => {
+	if (utf8ByteLength(value) <= maxBytes) return value;
+	const suffix = "…";
+	const suffixBytes = utf8ByteLength(suffix);
+	let output = "";
+	let bytes = 0;
+	for (const character of value) {
+		const characterBytes = utf8ByteLength(character);
+		if (bytes + characterBytes + suffixBytes > maxBytes) break;
+		output += character;
+		bytes += characterBytes;
+	}
+	return `${output}${suffix}`;
+};
+const encodeRunEvent = Schema.encodeEffect(RunEvent);
+/**
+* One composed step from live Run Events to structurally redacted transcript lines
+* (P7 WP7 friction fix; SEC-008/testing.md §12 "structurally redacted" live transcripts):
+* Schema-encode each event through the canonical `RunEvent` union, then pass the encoded
+* value through the configured `Redactor` — so the safe path is the short path and no live
+* suite hand-assembles (or accidentally skips) the encode→redact pair. Engine-constructed
+* events always encode, so an encode failure is a defect, never a silent omission.
+*/
+const redactedTranscript = (events) => Effect.gen(function* () {
+	const redactor = yield* Redactor;
+	const lines = [];
+	for (const event of events) {
+		const encoded = yield* encodeRunEvent(event).pipe(Effect.orDie);
+		lines.push(yield* redactor.redact(encoded));
+	}
+	return lines;
+});
+/**
+* Default structural implementation. It exposes only collection shape and
+* scalar types, so an ordinary field such as `note` cannot bypass redaction.
+* Tool-specific Layers may expose explicitly reviewed fields instead.
+*/
+const StructuralRedactorLive = Layer.succeed(Redactor)({ redact: (decodedValue) => Effect.try({
+	try: () => {
+		const structurallyRedacted = redactValue(decodedValue, 0, { nodes: 0 });
+		return truncateUtf8(JSON.stringify(structurallyRedacted), MAX_REDACTED_PREVIEW_BYTES);
+	},
+	catch: (cause) => Schema.is(RedactionError)(cause) ? cause : RedactionError.make({
+		reason: "encoding-failed",
+		message: "Could not encode the structurally redacted preview"
+	})
+}).pipe(Effect.flatMap((preview) => Schema.decodeEffect(RedactedPreview)(preview).pipe(Effect.mapError(() => RedactionError.make({
+	reason: "encoding-failed",
+	message: "Redacted preview did not satisfy its bounded schema"
+}))))) });
+//#endregion
+export { RedactedPreview, RedactionError, Redactor, StructuralRedactorLive, redactedTranscript, Redaction_exports as t };
+
+//# sourceMappingURL=Redaction.mjs.map