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

package/dist/core/SubagentContract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubagentContract.mjs","names":[],"sources":["../../src/core/SubagentContract.ts"],"sourcesContent":["import { Context, Schema } from \"effect\";\n\nimport { AgentId, ThreadId, DelegationId, RunId, ToolCallId, SubmissionId } from \"./Identifiers.ts\";\n\nconst Natural = Schema.Natural;\n\n/** Tree authority ceiling. Each child exposes only its own Toolkit's permitted names. */\nexport class SubagentGrant extends Schema.Class<SubagentGrant>(\n  \"@effect-agent/capabilities/SubagentGrant\",\n)({\n  allowedToolNames: Schema.Array(Schema.NonEmptyString).check(Schema.isMaxLength(128)),\n  maxDepth: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 16 })),\n  /** Omitted permits either lifetime within the depth and reserved subtree budgets. */\n  childLifetimes: Schema.optionalKey(\n    Schema.Array(Schema.Literals([\"attached\", \"background\"])).check(Schema.isMaxLength(2)),\n  ),\n}) {}\n\n/** Intersect inherited authority; another delegation can never restore a removed capability. */\nexport const narrowSubagentGrant = (\n  declared: SubagentGrant,\n  inherited?: SubagentGrant,\n): SubagentGrant =>\n  inherited === undefined\n    ? declared\n    : SubagentGrant.make({\n        allowedToolNames: declared.allowedToolNames.filter((name) =>\n          inherited.allowedToolNames.includes(name),\n        ),\n        maxDepth: Math.min(declared.maxDepth, inherited.maxDepth),\n        childLifetimes: (declared.childLifetimes ?? [\"attached\", \"background\"]).filter((lifetime) =>\n          (inherited.childLifetimes ?? [\"attached\", \"background\"]).includes(lifetime),\n        ),\n      });\n\n/** Finite delegable caps for one parent Run. Absent means not configured; present values are finite. */\nexport class SubagentDelegationCaps extends Schema.Class<SubagentDelegationCaps>(\n  \"@effect-agent/capabilities/SubagentDelegationCaps\",\n)({\n  maxTotalChildInvocations: Schema.optionalKey(Natural),\n  maxConcurrentChildren: Schema.optionalKey(Natural),\n  maxTurns: Schema.optionalKey(Natural),\n  maxToolCalls: Schema.optionalKey(Natural),\n  maxDurationMillis: Schema.optionalKey(Natural),\n  maxInputTokens: Schema.optionalKey(Natural),\n  maxOutputTokens: Schema.optionalKey(Natural),\n  maxCostMicrousd: Schema.optionalKey(Natural),\n  maxResultBytes: Schema.optionalKey(Natural),\n}) {}\n\nconst AmountFields = {\n  turns: Natural,\n  toolCalls: Natural,\n  durationMillis: Natural,\n  inputTokens: Natural,\n  outputTokens: Natural,\n  costMicrousd: Natural,\n  resultBytes: Natural,\n} as const;\n\n/** Exact amounts across every reservable delegation dimension. */\nexport class SubagentReservationAmounts extends Schema.Class<SubagentReservationAmounts>(\n  \"@effect-agent/capabilities/SubagentReservationAmounts\",\n)(AmountFields) {}\n\n/** One child reservation against the parent Run's shared delegation pool. */\nexport const SubagentBudgetReservation = Schema.Struct({\n  caps: SubagentDelegationCaps,\n  allocation: SubagentReservationAmounts,\n  /** Slots reserved for every descendant input beneath this input; absent reserves none. */\n  descendantInvocations: Schema.optionalKey(Natural),\n});\n\nexport type SubagentBudgetReservation = typeof SubagentBudgetReservation.Type;\n\n/** Root-relative delegation depth; the direct child of a top-level run has depth 1. */\nexport const DelegationDepth = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));\nexport type DelegationDepth = typeof DelegationDepth.Type;\n\n/** @deprecated Names are application-owned; use DelegationTool metadata for classification. */\nexport const delegationToolPrefix = \"delegate_\";\n\n/** @deprecated Checks a legacy spelling only, never execution, nesting or recovery semantics. */\nexport const isDelegationToolName = (toolName: string): boolean =>\n  toolName.startsWith(delegationToolPrefix);\n\n/** Marks a Tool implementing the idempotent Subagent establishment protocol. */\nexport const DelegationTool = Context.Reference<boolean>(\"@effect-agent/core/DelegationTool\", {\n  defaultValue: () => false,\n});\n\n/** Marks a host-managed idempotent worker operation, independently of its Tool name. */\nexport const WorkerOperationTool = Context.Reference<boolean>(\n  \"@effect-agent/core/WorkerOperationTool\",\n  {\n    defaultValue: () => false,\n  },\n);\n\n/** Identifies the background launch operation within a generated management Toolkit. */\nexport const BackgroundSpawnTool = Context.Reference<boolean>(\n  \"@effect-agent/core/BackgroundSpawnTool\",\n  {\n    defaultValue: () => false,\n  },\n);\n\n/** Declaration metadata and inherited authority determine the effective visible Tool set. */\nexport const isSubagentToolAllowed = (\n  grant: SubagentGrant | undefined,\n  depth: number,\n  name: string,\n  annotations: Context.Context<never>,\n): boolean =>\n  grant === undefined ||\n  (grant.allowedToolNames.includes(name) &&\n    (Context.get(annotations, BackgroundSpawnTool)\n      ? depth < grant.maxDepth &&\n        (grant.childLifetimes ?? [\"attached\", \"background\"]).includes(\"background\")\n      : Context.get(annotations, DelegationTool)\n        ? depth < grant.maxDepth &&\n          (grant.childLifetimes ?? [\"attached\", \"background\"]).includes(\"attached\")\n        : true));\n\n/** Persisted preparation classification, checked against the resolved Tool before replay. */\nexport const ToolExecutionKind = Schema.Literals([\"ordinary\", \"delegation\", \"orchestration\"]);\nexport type ToolExecutionKind = typeof ToolExecutionKind.Type;\n\n/** Resolve only trusted declaration metadata; names never authorize automatic replay. */\nexport const getToolExecutionKind = (annotations: Context.Context<never>): ToolExecutionKind =>\n  Context.get(annotations, WorkerOperationTool)\n    ? \"orchestration\"\n    : Context.get(annotations, DelegationTool)\n      ? \"delegation\"\n      : \"ordinary\";\n\n/** Immutable lineage from a child Thread to the parent identity that established it. */\nexport class SubagentParentLink extends Schema.Class<SubagentParentLink>(\"SubagentParentLink\")({\n  delegationId: DelegationId,\n  parentAgentId: AgentId,\n  parentThreadId: ThreadId,\n  parentRunId: RunId,\n  parentToolCallId: ToolCallId,\n  depth: DelegationDepth,\n}) {}\n\n/**\n * Classification of one bounded durable delegation failure.\n * `\"child-failed\"` and `\"child-aborted\"` project the\n * child's canonical failed/aborted Settlement; `\"child-compatibility\"`\n * projects the framework's `ChildCompatibilityFailure` child Settlement (the\n * stored child Binding digest was unavailable — recovery never substituted\n * current code); `\"establishment-denied\"` is a fail-closed coordinator\n * refusal (lineage/digest verification, divergent replay); and\n * `\"declaration-unavailable\"` is retained for decoding failures recorded by\n * versions that required an explicit durable digest declaration.\n */\nexport const SubagentExecutionFailureClassification = Schema.Literals([\n  \"child-failed\",\n  \"child-aborted\",\n  \"child-compatibility\",\n  \"establishment-denied\",\n  \"declaration-unavailable\",\n]);\n\nexport type SubagentExecutionFailureClassification =\n  typeof SubagentExecutionFailureClassification.Type;\n\nexport const maxErrorTagLength = 256;\nconst BoundedErrorTag = Schema.NonEmptyString.check(Schema.isMaxLength(maxErrorTagLength));\n\n/**\n * Bounded framework projection of a durable child failure, shared by attached joins and reports.\n * A failed or aborted durable child\n * joins its parent Tool Call as exactly this typed failure: a classification,\n * the child references, and the coordinator's bounded `{errorTag, message}`\n * projection — never a raw Cause, stack, provider response, secret, or child\n * payload. The typed child failure union does not survive a durable\n * Settlement, so `mapChildFailure` remains the ephemeral-path contract;\n * Schema-declared durable domain-failure mapping is a recorded later\n * extension.\n */\nexport class SubagentExecutionFailure extends Schema.TaggedError<SubagentExecutionFailure>()(\n  \"SubagentExecutionFailure\",\n  {\n    delegationId: DelegationId,\n    targetAgentId: AgentId,\n    classification: SubagentExecutionFailureClassification,\n    /** Child references, present once establishment reached a child identity. */\n    childThreadId: Schema.optionalKey(ThreadId),\n    childSubmissionId: Schema.optionalKey(SubmissionId),\n    childRunId: Schema.optionalKey(RunId),\n    errorTag: BoundedErrorTag,\n    message: Schema.String.check(Schema.isMaxLength(4 * 1024)),\n  },\n) {}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAIA,MAAM,UAAU,OAAO;;AAGvB,IAAa,gBAAb,cAAmC,OAAO,MACxC,0CACF,CAAC,CAAC;CACA,kBAAkB,OAAO,MAAM,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,YAAY,GAAG,CAAC;CACnF,UAAU,OAAO,IAAI,MAAM,OAAO,UAAU;EAAE,SAAS;EAAG,SAAS;CAAG,CAAC,CAAC;;CAExE,gBAAgB,OAAO,YACrB,OAAO,MAAM,OAAO,SAAS,CAAC,YAAY,YAAY,CAAC,CAAC,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC,CACvF;AACF,CAAC,CAAC,CAAC,CAAC;;AAGJ,MAAa,uBACX,UACA,cAEA,cAAc,KAAA,IACV,WACA,cAAc,KAAK;CACjB,kBAAkB,SAAS,iBAAiB,QAAQ,SAClD,UAAU,iBAAiB,SAAS,IAAI,CAC1C;CACA,UAAU,KAAK,IAAI,SAAS,UAAU,UAAU,QAAQ;CACxD,iBAAiB,SAAS,kBAAkB,CAAC,YAAY,YAAY,EAAA,CAAG,QAAQ,cAC7E,UAAU,kBAAkB,CAAC,YAAY,YAAY,EAAA,CAAG,SAAS,QAAQ,CAC5E;AACF,CAAC;;AAGP,IAAa,yBAAb,cAA4C,OAAO,MACjD,mDACF,CAAC,CAAC;CACA,0BAA0B,OAAO,YAAY,OAAO;CACpD,uBAAuB,OAAO,YAAY,OAAO;CACjD,UAAU,OAAO,YAAY,OAAO;CACpC,cAAc,OAAO,YAAY,OAAO;CACxC,mBAAmB,OAAO,YAAY,OAAO;CAC7C,gBAAgB,OAAO,YAAY,OAAO;CAC1C,iBAAiB,OAAO,YAAY,OAAO;CAC3C,iBAAiB,OAAO,YAAY,OAAO;CAC3C,gBAAgB,OAAO,YAAY,OAAO;AAC5C,CAAC,CAAC,CAAC,CAAC;AAEJ,MAAM,eAAe;CACnB,OAAO;CACP,WAAW;CACX,gBAAgB;CAChB,aAAa;CACb,cAAc;CACd,cAAc;CACd,aAAa;AACf;;AAGA,IAAa,6BAAb,cAAgD,OAAO,MACrD,uDACF,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC;;AAGjB,MAAa,4BAA4B,OAAO,OAAO;CACrD,MAAM;CACN,YAAY;;CAEZ,uBAAuB,OAAO,YAAY,OAAO;AACnD,CAAC;;AAKD,MAAa,kBAAkB,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC;;AAIhF,MAAa,uBAAuB;;AAGpC,MAAa,wBAAwB,aACnC,SAAS,WAAW,oBAAoB;;AAG1C,MAAa,iBAAiB,QAAQ,UAAmB,qCAAqC,EAC5F,oBAAoB,MACtB,CAAC;;AAGD,MAAa,sBAAsB,QAAQ,UACzC,0CACA,EACE,oBAAoB,MACtB,CACF;;AAGA,MAAa,sBAAsB,QAAQ,UACzC,0CACA,EACE,oBAAoB,MACtB,CACF;;AAGA,MAAa,yBACX,OACA,OACA,MACA,gBAEA,UAAU,KAAA,KACT,MAAM,iBAAiB,SAAS,IAAI,MAClC,QAAQ,IAAI,aAAa,mBAAmB,IACzC,QAAQ,MAAM,aACb,MAAM,kBAAkB,CAAC,YAAY,YAAY,EAAA,CAAG,SAAS,YAAY,IAC1E,QAAQ,IAAI,aAAa,cAAc,IACrC,QAAQ,MAAM,aACb,MAAM,kBAAkB,CAAC,YAAY,YAAY,EAAA,CAAG,SAAS,UAAU,IACxE;;AAGV,MAAa,oBAAoB,OAAO,SAAS;CAAC;CAAY;CAAc;AAAe,CAAC;;AAI5F,MAAa,wBAAwB,gBACnC,QAAQ,IAAI,aAAa,mBAAmB,IACxC,kBACA,QAAQ,IAAI,aAAa,cAAc,IACrC,eACA;;AAGR,IAAa,qBAAb,cAAwC,OAAO,MAA0B,oBAAoB,CAAC,CAAC;CAC7F,cAAc;CACd,eAAe;CACf,gBAAgB;CAChB,aAAa;CACb,kBAAkB;CAClB,OAAO;AACT,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;;AAaJ,MAAa,yCAAyC,OAAO,SAAS;CACpE;CACA;CACA;CACA;CACA;AACF,CAAC;AAKD,MAAa,oBAAoB;AACjC,MAAM,kBAAkB,OAAO,eAAe,MAAM,OAAO,YAAA,GAA6B,CAAC;;;;;;;;;;;;AAazF,IAAa,2BAAb,cAA8C,OAAO,YAAsC,CAAC,CAC1F,4BACA;CACE,cAAc;CACd,eAAe;CACf,gBAAgB;;CAEhB,eAAe,OAAO,YAAY,QAAQ;CAC1C,mBAAmB,OAAO,YAAY,YAAY;CAClD,YAAY,OAAO,YAAY,KAAK;CACpC,UAAU;CACV,SAAS,OAAO,OAAO,MAAM,OAAO,YAAY,IAAQ,CAAC;AAC3D,CACF,CAAC,CAAC,CAAC"}

package/dist/core/Thread.d.mts

@@ -0,0 +1,2 @@
+import { a as ThreadError, c as ThreadLimitExceeded, d as ThreadText, i as ThreadEncodingError, l as ThreadMessage, m as toPrompt, n as Thread, o as ThreadExport, p as layerMemory, r as ThreadAppend, s as ThreadHistoryDiverged, t as Store, u as ThreadNotFound } from "../Thread-DOBQ0QUY.mjs";
+export { Store, Thread, ThreadAppend, ThreadEncodingError, ThreadError, ThreadExport, ThreadHistoryDiverged, ThreadLimitExceeded, ThreadMessage, ThreadNotFound, ThreadText, layerMemory, toPrompt };

package/dist/core/Thread.mjs

@@ -0,0 +1,250 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength } from "../utf8-DchGZRBd.mjs";
+import { RunId, ThreadId } from "./Identifiers.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { Clock, Context, DateTime, Effect, Layer, Schema, SynchronizedRef } from "effect";
+//#region src/core/Thread.ts
+var Thread_exports = /* @__PURE__ */ __exportAll({
+	Store: () => Store,
+	Thread: () => Thread,
+	ThreadAppend: () => ThreadAppend,
+	ThreadEncodingError: () => ThreadEncodingError,
+	ThreadExport: () => ThreadExport,
+	ThreadHistoryDiverged: () => ThreadHistoryDiverged,
+	ThreadLimitExceeded: () => ThreadLimitExceeded,
+	ThreadMessage: () => ThreadMessage,
+	ThreadNotFound: () => ThreadNotFound,
+	ThreadText: () => ThreadText,
+	layerMemory: () => layerMemory,
+	toPrompt: () => toPrompt
+});
+/** Bound applied to one text projection before it can enter a model context. */
+const ThreadText = Schema.String.check(Schema.isMaxLength(65536));
+const MAX_THREAD_MESSAGES = 1024;
+const MAX_THREAD_CONTENT_BYTES = 4194304;
+const MAX_THREADS = 256;
+const MAX_STORE_CONTENT_BYTES = 67108864;
+/** One append-only native Effect AI message in a conversation. */
+var ThreadMessage = class extends Schema.Class("@effect-agent/capabilities/ThreadMessage")({
+	threadId: ThreadId,
+	sequence: Schema.Natural,
+	runId: Schema.optionalKey(RunId),
+	message: Prompt.Message,
+	encodedBytes: Schema.Natural.check(Schema.isLessThanOrEqualTo(MAX_THREAD_CONTENT_BYTES)),
+	timestamp: Schema.DateTimeUtcFromString
+}) {};
+/** An identified, ordered conversation snapshot. Storage and execution recovery are separate concerns. */
+var Thread = class extends Schema.Class("@effect-agent/capabilities/ThreadSnapshot")({
+	version: Schema.Literal(1),
+	threadId: ThreadId,
+	nextSequence: Schema.Natural,
+	contentBytes: Schema.Natural.check(Schema.isLessThanOrEqualTo(MAX_THREAD_CONTENT_BYTES)),
+	messages: Schema.Array(ThreadMessage).check(Schema.isMaxLength(MAX_THREAD_MESSAGES))
+}) {};
+/** Portable conversation snapshot. Its format is independent of the durable execution journal. */
+var ThreadExport = class extends Schema.Class("@effect-agent/capabilities/ThreadExport")({
+	format: Schema.Literal("effect-agent/ephemeral-thread@1"),
+	exportedAt: Schema.DateTimeUtcFromString,
+	snapshot: Thread
+}) {};
+/** Native message accepted by the append-only thread. */
+var ThreadAppend = class extends Schema.Class("@effect-agent/capabilities/ThreadAppend")({
+	runId: Schema.optionalKey(RunId),
+	message: Prompt.Message
+}) {};
+/** The requested Thread has not been created in this store. */
+var ThreadNotFound = class extends Schema.TaggedError()("ThreadNotFound", { threadId: ThreadId }) {};
+/** A process-local Thread store reached an explicit count or encoded-content bound. */
+var ThreadLimitExceeded = class extends Schema.TaggedError()("ThreadLimitExceeded", {
+	threadId: ThreadId,
+	limit: Schema.Literals([
+		"messages",
+		"content-bytes",
+		"threads",
+		"store-content-bytes"
+	]),
+	limitValue: Schema.Natural,
+	observedValue: Schema.Natural
+}) {};
+/** Engine history was not an append-only extension of the official snapshot. */
+var ThreadHistoryDiverged = class extends Schema.TaggedError()("ThreadHistoryDiverged", {
+	threadId: ThreadId,
+	message: Schema.String
+}) {};
+/** Native Prompt encoding failed before a bounded state mutation. */
+var ThreadEncodingError = class extends Schema.TaggedError()("ThreadEncodingError", {
+	threadId: ThreadId,
+	message: Schema.String
+}) {};
+/** Reconstruct exact Effect AI Prompt history, including tools, reasoning, files, and options. */
+const toPrompt = (snapshot) => Prompt.fromMessages(snapshot.messages.map((entry) => entry.message));
+/**
+* Process-local state for conversation history. Updates remain visible even
+* when a Run later fails; this service has no successful-Run commit boundary or durable recovery.
+* ThreadHistory.layer uses this store for ordinary Runs and interactive history.
+* Scope closure releases all in-memory state.
+*/
+var Store = class extends Context.Service()("@effect-agent/capabilities/EphemeralThreads") {};
+const encodeMessage = (threadId, message) => Schema.encodeEffect(Prompt.Message)(message).pipe(Effect.map((encoded) => JSON.stringify(encoded)), Effect.mapError((error) => ThreadEncodingError.make({
+	threadId,
+	message: `Could not encode native Effect AI message: ${error.message}`
+})));
+const findSnapshot = (state, threadId) => {
+	const snapshot = state.get(threadId);
+	return snapshot === void 0 ? Effect.fail(ThreadNotFound.make({ threadId })) : Effect.succeed(snapshot);
+};
+const totalStoreBytes = (threads) => {
+	let total = 0;
+	for (const snapshot of threads.values()) total += snapshot.contentBytes;
+	return total;
+};
+const appendEncoded = Effect.fn("Thread.Store.appendEncoded")(function* (threads, current, append, encoded, timestamp) {
+	const threadId = current.threadId;
+	if (current.messages.length >= MAX_THREAD_MESSAGES) return yield* ThreadLimitExceeded.make({
+		threadId,
+		limit: "messages",
+		limitValue: MAX_THREAD_MESSAGES,
+		observedValue: current.messages.length + 1
+	});
+	const messageBytes = utf8ByteLength(encoded);
+	const contentBytes = current.contentBytes + messageBytes;
+	if (contentBytes > MAX_THREAD_CONTENT_BYTES) return yield* ThreadLimitExceeded.make({
+		threadId,
+		limit: "content-bytes",
+		limitValue: MAX_THREAD_CONTENT_BYTES,
+		observedValue: contentBytes
+	});
+	const storeBytes = totalStoreBytes(threads) + messageBytes;
+	if (storeBytes > MAX_STORE_CONTENT_BYTES) return yield* ThreadLimitExceeded.make({
+		threadId,
+		limit: "store-content-bytes",
+		limitValue: MAX_STORE_CONTENT_BYTES,
+		observedValue: storeBytes
+	});
+	const message = ThreadMessage.make({
+		threadId,
+		sequence: current.nextSequence,
+		...append.runId === void 0 ? {} : { runId: append.runId },
+		message: append.message,
+		encodedBytes: messageBytes,
+		timestamp
+	});
+	const next = Thread.make({
+		version: current.version,
+		threadId: current.threadId,
+		nextSequence: current.nextSequence + 1,
+		contentBytes,
+		messages: [...current.messages, message]
+	});
+	return [next, new Map(threads).set(threadId, next)];
+});
+/** In-memory storage shared for the consumer's Scope; it does not survive process loss. */
+const layerMemory = Layer.effect(Store, Effect.gen(function* () {
+	const state = yield* SynchronizedRef.make(/* @__PURE__ */ new Map());
+	yield* Effect.addFinalizer(() => SynchronizedRef.set(state, /* @__PURE__ */ new Map()));
+	return Store.of({
+		create: (threadId) => SynchronizedRef.modifyEffect(state, Effect.fn(function* (threads) {
+			const existing = threads.get(threadId);
+			if (existing !== void 0) return [existing, threads];
+			if (threads.size >= MAX_THREADS) return yield* ThreadLimitExceeded.make({
+				threadId,
+				limit: "threads",
+				limitValue: MAX_THREADS,
+				observedValue: threads.size + 1
+			});
+			const created = Thread.make({
+				version: 1,
+				threadId,
+				nextSequence: 0,
+				contentBytes: 0,
+				messages: []
+			});
+			return [created, new Map(threads).set(threadId, created)];
+		})),
+		append: Effect.fn("Thread.Store.append")(function* (threadId, message) {
+			const encoded = yield* encodeMessage(threadId, message.message);
+			const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));
+			return yield* SynchronizedRef.modifyEffect(state, Effect.fn(function* (threads) {
+				const current = yield* findSnapshot(threads, threadId);
+				return yield* appendEncoded(threads, current, message, encoded, timestamp);
+			}));
+		}),
+		recordHistory: Effect.fn("Thread.Store.recordHistory")(function* (threadId, historyRunId, history) {
+			const incoming = yield* Effect.forEach(history.content, (message) => encodeMessage(threadId, message).pipe(Effect.map((encoded) => ({
+				message,
+				encoded
+			}))));
+			return yield* SynchronizedRef.modifyEffect(state, Effect.fn(function* (threads) {
+				const current = yield* findSnapshot(threads, threadId);
+				const currentEncoded = yield* Effect.forEach(current.messages, (entry) => encodeMessage(threadId, entry.message));
+				if (incoming.length < currentEncoded.length || currentEncoded.some((encoded, index) => encoded !== incoming[index]?.encoded)) return yield* ThreadHistoryDiverged.make({
+					threadId,
+					message: "Engine history is not an append-only extension of official history"
+				});
+				const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));
+				if (incoming.length === currentEncoded.length) return [current, threads];
+				const messages = [...current.messages];
+				let contentBytes = current.contentBytes;
+				let storeBytes = totalStoreBytes(threads);
+				let nextSequence = current.nextSequence;
+				for (const entry of incoming.slice(currentEncoded.length)) {
+					const append = ThreadAppend.make({
+						runId: historyRunId,
+						message: entry.message
+					});
+					if (messages.length >= MAX_THREAD_MESSAGES) return yield* ThreadLimitExceeded.make({
+						threadId,
+						limit: "messages",
+						limitValue: MAX_THREAD_MESSAGES,
+						observedValue: messages.length + 1
+					});
+					const messageBytes = utf8ByteLength(entry.encoded);
+					contentBytes += messageBytes;
+					if (contentBytes > MAX_THREAD_CONTENT_BYTES) return yield* ThreadLimitExceeded.make({
+						threadId,
+						limit: "content-bytes",
+						limitValue: MAX_THREAD_CONTENT_BYTES,
+						observedValue: contentBytes
+					});
+					storeBytes += messageBytes;
+					if (storeBytes > MAX_STORE_CONTENT_BYTES) return yield* ThreadLimitExceeded.make({
+						threadId,
+						limit: "store-content-bytes",
+						limitValue: MAX_STORE_CONTENT_BYTES,
+						observedValue: storeBytes
+					});
+					messages.push(ThreadMessage.make({
+						threadId,
+						sequence: nextSequence,
+						...append.runId === void 0 ? {} : { runId: append.runId },
+						message: append.message,
+						encodedBytes: messageBytes,
+						timestamp
+					}));
+					nextSequence += 1;
+				}
+				const snapshot = Thread.make({
+					version: current.version,
+					threadId,
+					nextSequence,
+					contentBytes,
+					messages
+				});
+				return [snapshot, new Map(threads).set(threadId, snapshot)];
+			}));
+		}),
+		snapshot: (threadId) => SynchronizedRef.get(state).pipe(Effect.flatMap((all) => findSnapshot(all, threadId))),
+		export: (threadId) => Effect.gen(function* () {
+			const snapshot = yield* findSnapshot(yield* SynchronizedRef.get(state), threadId);
+			return ThreadExport.make({
+				format: "effect-agent/ephemeral-thread@1",
+				exportedAt: DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis)),
+				snapshot
+			});
+		})
+	});
+}));
+//#endregion
+export { Store, Thread, ThreadAppend, ThreadEncodingError, ThreadExport, ThreadHistoryDiverged, ThreadLimitExceeded, ThreadMessage, ThreadNotFound, ThreadText, layerMemory, Thread_exports as t, toPrompt };
+
+//# sourceMappingURL=Thread.mjs.map

package/dist/core/Thread.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Thread.mjs","names":[],"sources":["../../src/core/Thread.ts"],"sourcesContent":["import { Clock, Context, DateTime, Effect, Layer, Schema, SynchronizedRef } from \"effect\";\nimport { Prompt } from \"effect/unstable/ai\";\n\nimport { ThreadId, RunId } from \"./Identifiers.ts\";\nimport { utf8ByteLength } from \"./internal/utf8.ts\";\n\n/** Bound applied to one text projection before it can enter a model context. */\nexport const ThreadText = Schema.String.check(Schema.isMaxLength(64 * 1024));\nconst MAX_THREAD_MESSAGES = 1_024;\nconst MAX_THREAD_CONTENT_BYTES = 4 * 1024 * 1024;\nconst MAX_THREADS = 256;\nconst MAX_STORE_CONTENT_BYTES = 64 * 1024 * 1024;\n\n/** One append-only native Effect AI message in a conversation. */\nexport class ThreadMessage extends Schema.Class<ThreadMessage>(\n  \"@effect-agent/capabilities/ThreadMessage\",\n)({\n  threadId: ThreadId,\n  sequence: Schema.Natural,\n  runId: Schema.optionalKey(RunId),\n  message: Prompt.Message,\n  encodedBytes: Schema.Natural.check(Schema.isLessThanOrEqualTo(MAX_THREAD_CONTENT_BYTES)),\n  timestamp: Schema.DateTimeUtcFromString,\n}) {}\n\n/** An identified, ordered conversation snapshot. Storage and execution recovery are separate concerns. */\nexport class Thread extends Schema.Class<Thread>(\"@effect-agent/capabilities/ThreadSnapshot\")({\n  version: Schema.Literal(1),\n  threadId: ThreadId,\n  nextSequence: Schema.Natural,\n  contentBytes: Schema.Natural.check(Schema.isLessThanOrEqualTo(MAX_THREAD_CONTENT_BYTES)),\n  messages: Schema.Array(ThreadMessage).check(Schema.isMaxLength(MAX_THREAD_MESSAGES)),\n}) {}\n\n/** Portable conversation snapshot. Its format is independent of the durable execution journal. */\nexport class ThreadExport extends Schema.Class<ThreadExport>(\n  \"@effect-agent/capabilities/ThreadExport\",\n)({\n  format: Schema.Literal(\"effect-agent/ephemeral-thread@1\"),\n  exportedAt: Schema.DateTimeUtcFromString,\n  snapshot: Thread,\n}) {}\n\n/** Native message accepted by the append-only thread. */\nexport class ThreadAppend extends Schema.Class<ThreadAppend>(\n  \"@effect-agent/capabilities/ThreadAppend\",\n)({\n  runId: Schema.optionalKey(RunId),\n  message: Prompt.Message,\n}) {}\n\n/** The requested Thread has not been created in this store. */\nexport class ThreadNotFound extends Schema.TaggedError<ThreadNotFound>()(\"ThreadNotFound\", {\n  threadId: ThreadId,\n}) {}\n\n/** A process-local Thread store reached an explicit count or encoded-content bound. */\nexport class ThreadLimitExceeded extends Schema.TaggedError<ThreadLimitExceeded>()(\n  \"ThreadLimitExceeded\",\n  {\n    threadId: ThreadId,\n    limit: Schema.Literals([\"messages\", \"content-bytes\", \"threads\", \"store-content-bytes\"]),\n    limitValue: Schema.Natural,\n    observedValue: Schema.Natural,\n  },\n) {}\n\n/** Engine history was not an append-only extension of the official snapshot. */\nexport class ThreadHistoryDiverged extends Schema.TaggedError<ThreadHistoryDiverged>()(\n  \"ThreadHistoryDiverged\",\n  { threadId: ThreadId, message: Schema.String },\n) {}\n\n/** Native Prompt encoding failed before a bounded state mutation. */\nexport class ThreadEncodingError extends Schema.TaggedError<ThreadEncodingError>()(\n  \"ThreadEncodingError\",\n  { threadId: ThreadId, message: Schema.String },\n) {}\n\nexport type ThreadError =\n  | ThreadNotFound\n  | ThreadLimitExceeded\n  | ThreadHistoryDiverged\n  | ThreadEncodingError;\n\n/** Reconstruct exact Effect AI Prompt history, including tools, reasoning, files, and options. */\nexport const toPrompt = (snapshot: Thread): Prompt.Prompt =>\n  Prompt.fromMessages(snapshot.messages.map((entry) => entry.message));\n\n/**\n * Process-local state for conversation history. Updates remain visible even\n * when a Run later fails; this service has no successful-Run commit boundary or durable recovery.\n * ThreadHistory.layer uses this store for ordinary Runs and interactive history.\n * Scope closure releases all in-memory state.\n */\nexport class Store extends Context.Service<\n  Store,\n  {\n    readonly create: (threadId: ThreadId) => Effect.Effect<Thread, ThreadLimitExceeded>;\n    readonly append: (\n      threadId: ThreadId,\n      message: ThreadAppend,\n    ) => Effect.Effect<Thread, ThreadNotFound | ThreadLimitExceeded | ThreadEncodingError>;\n    /**\n     * Record an engine-emitted full history only when it is an append-only\n     * extension of the exact official Prompt already stored. The entire\n     * suffix commits in one transaction or not at all: concurrent writers are\n     * serialized, a writer whose history no longer extends the committed\n     * official history fails with ThreadHistoryDiverged, and a limit\n     * failure inside the suffix records nothing. Earlier updates remain committed if the Run\n     * later fails or is interrupted; this transaction covers one update, not the whole Run.\n     */\n    readonly recordHistory: (\n      threadId: ThreadId,\n      runId: RunId,\n      history: Prompt.Prompt,\n    ) => Effect.Effect<Thread, ThreadError>;\n    readonly snapshot: (threadId: ThreadId) => Effect.Effect<Thread, ThreadNotFound>;\n    readonly export: (threadId: ThreadId) => Effect.Effect<ThreadExport, ThreadNotFound>;\n  }\n>()(\"@effect-agent/capabilities/EphemeralThreads\") {}\n\nconst encodeMessage = (\n  threadId: ThreadId,\n  message: Prompt.Message,\n): Effect.Effect<string, ThreadEncodingError> =>\n  Schema.encodeEffect(Prompt.Message)(message).pipe(\n    Effect.map((encoded) => JSON.stringify(encoded)),\n    Effect.mapError((error) =>\n      ThreadEncodingError.make({\n        threadId,\n        message: `Could not encode native Effect AI message: ${error.message}`,\n      }),\n    ),\n  );\n\nconst findSnapshot = (\n  state: ReadonlyMap<ThreadId, Thread>,\n  threadId: ThreadId,\n): Effect.Effect<Thread, ThreadNotFound> => {\n  const snapshot = state.get(threadId);\n\n  return snapshot === undefined\n    ? Effect.fail(ThreadNotFound.make({ threadId }))\n    : Effect.succeed(snapshot);\n};\n\nconst totalStoreBytes = (threads: ReadonlyMap<ThreadId, Thread>): number => {\n  let total = 0;\n\n  for (const snapshot of threads.values()) total += snapshot.contentBytes;\n\n  return total;\n};\n\nconst appendEncoded = Effect.fn(\"Thread.Store.appendEncoded\")(function* (\n  threads: ReadonlyMap<ThreadId, Thread>,\n  current: Thread,\n  append: ThreadAppend,\n  encoded: string,\n  timestamp: DateTime.Utc,\n) {\n  const threadId = current.threadId;\n\n  if (current.messages.length >= MAX_THREAD_MESSAGES) {\n    return yield* ThreadLimitExceeded.make({\n      threadId,\n      limit: \"messages\",\n      limitValue: MAX_THREAD_MESSAGES,\n      observedValue: current.messages.length + 1,\n    });\n  }\n  const messageBytes = utf8ByteLength(encoded);\n  const contentBytes = current.contentBytes + messageBytes;\n\n  if (contentBytes > MAX_THREAD_CONTENT_BYTES) {\n    return yield* ThreadLimitExceeded.make({\n      threadId,\n      limit: \"content-bytes\",\n      limitValue: MAX_THREAD_CONTENT_BYTES,\n      observedValue: contentBytes,\n    });\n  }\n  const storeBytes = totalStoreBytes(threads) + messageBytes;\n\n  if (storeBytes > MAX_STORE_CONTENT_BYTES) {\n    return yield* ThreadLimitExceeded.make({\n      threadId,\n      limit: \"store-content-bytes\",\n      limitValue: MAX_STORE_CONTENT_BYTES,\n      observedValue: storeBytes,\n    });\n  }\n\n  const message = ThreadMessage.make({\n    threadId,\n    sequence: current.nextSequence,\n    ...(append.runId === undefined ? {} : { runId: append.runId }),\n    message: append.message,\n    encodedBytes: messageBytes,\n    timestamp,\n  });\n\n  const next = Thread.make({\n    version: current.version,\n    threadId: current.threadId,\n    nextSequence: current.nextSequence + 1,\n    contentBytes,\n    messages: [...current.messages, message],\n  });\n\n  return [next, new Map(threads).set(threadId, next)] as const;\n});\n\n/** In-memory storage shared for the consumer's Scope; it does not survive process loss. */\nexport const layerMemory = Layer.effect(\n  Store,\n  Effect.gen(function* () {\n    const state = yield* SynchronizedRef.make<ReadonlyMap<ThreadId, Thread>>(new Map());\n\n    yield* Effect.addFinalizer(() => SynchronizedRef.set(state, new Map()));\n\n    return Store.of({\n      create: (threadId) =>\n        SynchronizedRef.modifyEffect(\n          state,\n          Effect.fn(function* (threads) {\n            const existing = threads.get(threadId);\n\n            if (existing !== undefined) return [existing, threads] as const;\n            if (threads.size >= MAX_THREADS) {\n              return yield* ThreadLimitExceeded.make({\n                threadId,\n                limit: \"threads\",\n                limitValue: MAX_THREADS,\n                observedValue: threads.size + 1,\n              });\n            }\n\n            const created = Thread.make({\n              version: 1,\n              threadId,\n              nextSequence: 0,\n              contentBytes: 0,\n              messages: [],\n            });\n\n            return [created, new Map(threads).set(threadId, created)] as const;\n          }),\n        ),\n      append: Effect.fn(\"Thread.Store.append\")(function* (threadId, message) {\n        const encoded = yield* encodeMessage(threadId, message.message);\n        const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));\n\n        return yield* SynchronizedRef.modifyEffect(\n          state,\n          Effect.fn(function* (threads) {\n            const current = yield* findSnapshot(threads, threadId);\n\n            return yield* appendEncoded(threads, current, message, encoded, timestamp);\n          }),\n        );\n      }),\n      recordHistory: Effect.fn(\"Thread.Store.recordHistory\")(\n        function* (threadId, historyRunId, history) {\n          const incoming = yield* Effect.forEach(history.content, (message) =>\n            encodeMessage(threadId, message).pipe(Effect.map((encoded) => ({ message, encoded }))),\n          );\n\n          // Publish the complete suffix only after verification and every bounded append succeed.\n          return yield* SynchronizedRef.modifyEffect(\n            state,\n            Effect.fn(function* (threads) {\n              const current = yield* findSnapshot(threads, threadId);\n\n              const currentEncoded = yield* Effect.forEach(current.messages, (entry) =>\n                encodeMessage(threadId, entry.message),\n              );\n\n              if (\n                incoming.length < currentEncoded.length ||\n                currentEncoded.some((encoded, index) => encoded !== incoming[index]?.encoded)\n              ) {\n                return yield* ThreadHistoryDiverged.make({\n                  threadId,\n                  message: \"Engine history is not an append-only extension of official history\",\n                });\n              }\n              const timestamp = DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis));\n\n              if (incoming.length === currentEncoded.length) return [current, threads] as const;\n\n              const messages = [...current.messages];\n              let contentBytes = current.contentBytes;\n              let storeBytes = totalStoreBytes(threads);\n              let nextSequence = current.nextSequence;\n\n              for (const entry of incoming.slice(currentEncoded.length)) {\n                const append = ThreadAppend.make({ runId: historyRunId, message: entry.message });\n\n                // Preserve append's first failing bound and observed value without publishing\n                // intermediate snapshots or rescanning the store for each suffix message.\n                if (messages.length >= MAX_THREAD_MESSAGES) {\n                  return yield* ThreadLimitExceeded.make({\n                    threadId,\n                    limit: \"messages\",\n                    limitValue: MAX_THREAD_MESSAGES,\n                    observedValue: messages.length + 1,\n                  });\n                }\n                const messageBytes = utf8ByteLength(entry.encoded);\n\n                contentBytes += messageBytes;\n                if (contentBytes > MAX_THREAD_CONTENT_BYTES) {\n                  return yield* ThreadLimitExceeded.make({\n                    threadId,\n                    limit: \"content-bytes\",\n                    limitValue: MAX_THREAD_CONTENT_BYTES,\n                    observedValue: contentBytes,\n                  });\n                }\n                storeBytes += messageBytes;\n                if (storeBytes > MAX_STORE_CONTENT_BYTES) {\n                  return yield* ThreadLimitExceeded.make({\n                    threadId,\n                    limit: \"store-content-bytes\",\n                    limitValue: MAX_STORE_CONTENT_BYTES,\n                    observedValue: storeBytes,\n                  });\n                }\n                messages.push(\n                  ThreadMessage.make({\n                    threadId,\n                    sequence: nextSequence,\n                    ...(append.runId === undefined ? {} : { runId: append.runId }),\n                    message: append.message,\n                    encodedBytes: messageBytes,\n                    timestamp,\n                  }),\n                );\n                nextSequence += 1;\n              }\n\n              const snapshot = Thread.make({\n                version: current.version,\n                threadId,\n                nextSequence,\n                contentBytes,\n                messages,\n              });\n\n              return [snapshot, new Map(threads).set(threadId, snapshot)] as const;\n            }),\n          );\n        },\n      ),\n      snapshot: (threadId) =>\n        SynchronizedRef.get(state).pipe(Effect.flatMap((all) => findSnapshot(all, threadId))),\n      export: (threadId) =>\n        Effect.gen(function* () {\n          const snapshot = yield* findSnapshot(yield* SynchronizedRef.get(state), threadId);\n\n          return ThreadExport.make({\n            format: \"effect-agent/ephemeral-thread@1\",\n            exportedAt: DateTime.toUtc(DateTime.makeUnsafe(yield* Clock.currentTimeMillis)),\n            snapshot,\n          });\n        }),\n    });\n  }),\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAOA,MAAa,aAAa,OAAO,OAAO,MAAM,OAAO,YAAY,KAAS,CAAC;AAC3E,MAAM,sBAAsB;AAC5B,MAAM,2BAA2B;AACjC,MAAM,cAAc;AACpB,MAAM,0BAA0B;;AAGhC,IAAa,gBAAb,cAAmC,OAAO,MACxC,0CACF,CAAC,CAAC;CACA,UAAU;CACV,UAAU,OAAO;CACjB,OAAO,OAAO,YAAY,KAAK;CAC/B,SAAS,OAAO;CAChB,cAAc,OAAO,QAAQ,MAAM,OAAO,oBAAoB,wBAAwB,CAAC;CACvF,WAAW,OAAO;AACpB,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,SAAb,cAA4B,OAAO,MAAc,2CAA2C,CAAC,CAAC;CAC5F,SAAS,OAAO,QAAQ,CAAC;CACzB,UAAU;CACV,cAAc,OAAO;CACrB,cAAc,OAAO,QAAQ,MAAM,OAAO,oBAAoB,wBAAwB,CAAC;CACvF,UAAU,OAAO,MAAM,aAAa,CAAC,CAAC,MAAM,OAAO,YAAY,mBAAmB,CAAC;AACrF,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,eAAb,cAAkC,OAAO,MACvC,yCACF,CAAC,CAAC;CACA,QAAQ,OAAO,QAAQ,iCAAiC;CACxD,YAAY,OAAO;CACnB,UAAU;AACZ,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,eAAb,cAAkC,OAAO,MACvC,yCACF,CAAC,CAAC;CACA,OAAO,OAAO,YAAY,KAAK;CAC/B,SAAS,OAAO;AAClB,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,iBAAb,cAAoC,OAAO,YAA4B,CAAC,CAAC,kBAAkB,EACzF,UAAU,SACZ,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CACE,UAAU;CACV,OAAO,OAAO,SAAS;EAAC;EAAY;EAAiB;EAAW;CAAqB,CAAC;CACtF,YAAY,OAAO;CACnB,eAAe,OAAO;AACxB,CACF,CAAC,CAAC,CAAC;;AAGH,IAAa,wBAAb,cAA2C,OAAO,YAAmC,CAAC,CACpF,yBACA;CAAE,UAAU;CAAU,SAAS,OAAO;AAAO,CAC/C,CAAC,CAAC,CAAC;;AAGH,IAAa,sBAAb,cAAyC,OAAO,YAAiC,CAAC,CAChF,uBACA;CAAE,UAAU;CAAU,SAAS,OAAO;AAAO,CAC/C,CAAC,CAAC,CAAC;;AASH,MAAa,YAAY,aACvB,OAAO,aAAa,SAAS,SAAS,KAAK,UAAU,MAAM,OAAO,CAAC;;;;;;;AAQrE,IAAa,QAAb,cAA2B,QAAQ,QAyBjC,CAAC,CAAC,6CAA6C,CAAC,CAAC,CAAC;AAEpD,MAAM,iBACJ,UACA,YAEA,OAAO,aAAa,OAAO,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,KAC3C,OAAO,KAAK,YAAY,KAAK,UAAU,OAAO,CAAC,GAC/C,OAAO,UAAU,UACf,oBAAoB,KAAK;CACvB;CACA,SAAS,8CAA8C,MAAM;AAC/D,CAAC,CACH,CACF;AAEF,MAAM,gBACJ,OACA,aAC0C;CAC1C,MAAM,WAAW,MAAM,IAAI,QAAQ;CAEnC,OAAO,aAAa,KAAA,IAChB,OAAO,KAAK,eAAe,KAAK,EAAE,SAAS,CAAC,CAAC,IAC7C,OAAO,QAAQ,QAAQ;AAC7B;AAEA,MAAM,mBAAmB,YAAmD;CAC1E,IAAI,QAAQ;CAEZ,KAAK,MAAM,YAAY,QAAQ,OAAO,GAAG,SAAS,SAAS;CAE3D,OAAO;AACT;AAEA,MAAM,gBAAgB,OAAO,GAAG,4BAA4B,CAAC,CAAC,WAC5D,SACA,SACA,QACA,SACA,WACA;CACA,MAAM,WAAW,QAAQ;CAEzB,IAAI,QAAQ,SAAS,UAAU,qBAC7B,OAAO,OAAO,oBAAoB,KAAK;EACrC;EACA,OAAO;EACP,YAAY;EACZ,eAAe,QAAQ,SAAS,SAAS;CAC3C,CAAC;CAEH,MAAM,eAAe,eAAe,OAAO;CAC3C,MAAM,eAAe,QAAQ,eAAe;CAE5C,IAAI,eAAe,0BACjB,OAAO,OAAO,oBAAoB,KAAK;EACrC;EACA,OAAO;EACP,YAAY;EACZ,eAAe;CACjB,CAAC;CAEH,MAAM,aAAa,gBAAgB,OAAO,IAAI;CAE9C,IAAI,aAAa,yBACf,OAAO,OAAO,oBAAoB,KAAK;EACrC;EACA,OAAO;EACP,YAAY;EACZ,eAAe;CACjB,CAAC;CAGH,MAAM,UAAU,cAAc,KAAK;EACjC;EACA,UAAU,QAAQ;EAClB,GAAI,OAAO,UAAU,KAAA,IAAY,CAAC,IAAI,EAAE,OAAO,OAAO,MAAM;EAC5D,SAAS,OAAO;EAChB,cAAc;EACd;CACF,CAAC;CAED,MAAM,OAAO,OAAO,KAAK;EACvB,SAAS,QAAQ;EACjB,UAAU,QAAQ;EAClB,cAAc,QAAQ,eAAe;EACrC;EACA,UAAU,CAAC,GAAG,QAAQ,UAAU,OAAO;CACzC,CAAC;CAED,OAAO,CAAC,MAAM,IAAI,IAAI,OAAO,CAAC,CAAC,IAAI,UAAU,IAAI,CAAC;AACpD,CAAC;;AAGD,MAAa,cAAc,MAAM,OAC/B,OACA,OAAO,IAAI,aAAa;CACtB,MAAM,QAAQ,OAAO,gBAAgB,qBAAoC,IAAI,IAAI,CAAC;CAElF,OAAO,OAAO,mBAAmB,gBAAgB,IAAI,uBAAO,IAAI,IAAI,CAAC,CAAC;CAEtE,OAAO,MAAM,GAAG;EACd,SAAS,aACP,gBAAgB,aACd,OACA,OAAO,GAAG,WAAW,SAAS;GAC5B,MAAM,WAAW,QAAQ,IAAI,QAAQ;GAErC,IAAI,aAAa,KAAA,GAAW,OAAO,CAAC,UAAU,OAAO;GACrD,IAAI,QAAQ,QAAQ,aAClB,OAAO,OAAO,oBAAoB,KAAK;IACrC;IACA,OAAO;IACP,YAAY;IACZ,eAAe,QAAQ,OAAO;GAChC,CAAC;GAGH,MAAM,UAAU,OAAO,KAAK;IAC1B,SAAS;IACT;IACA,cAAc;IACd,cAAc;IACd,UAAU,CAAC;GACb,CAAC;GAED,OAAO,CAAC,SAAS,IAAI,IAAI,OAAO,CAAC,CAAC,IAAI,UAAU,OAAO,CAAC;EAC1D,CAAC,CACH;EACF,QAAQ,OAAO,GAAG,qBAAqB,CAAC,CAAC,WAAW,UAAU,SAAS;GACrE,MAAM,UAAU,OAAO,cAAc,UAAU,QAAQ,OAAO;GAC9D,MAAM,YAAY,SAAS,MAAM,SAAS,WAAW,OAAO,MAAM,iBAAiB,CAAC;GAEpF,OAAO,OAAO,gBAAgB,aAC5B,OACA,OAAO,GAAG,WAAW,SAAS;IAC5B,MAAM,UAAU,OAAO,aAAa,SAAS,QAAQ;IAErD,OAAO,OAAO,cAAc,SAAS,SAAS,SAAS,SAAS,SAAS;GAC3E,CAAC,CACH;EACF,CAAC;EACD,eAAe,OAAO,GAAG,4BAA4B,CAAC,CACpD,WAAW,UAAU,cAAc,SAAS;GAC1C,MAAM,WAAW,OAAO,OAAO,QAAQ,QAAQ,UAAU,YACvD,cAAc,UAAU,OAAO,CAAC,CAAC,KAAK,OAAO,KAAK,aAAa;IAAE;IAAS;GAAQ,EAAE,CAAC,CACvF;GAGA,OAAO,OAAO,gBAAgB,aAC5B,OACA,OAAO,GAAG,WAAW,SAAS;IAC5B,MAAM,UAAU,OAAO,aAAa,SAAS,QAAQ;IAErD,MAAM,iBAAiB,OAAO,OAAO,QAAQ,QAAQ,WAAW,UAC9D,cAAc,UAAU,MAAM,OAAO,CACvC;IAEA,IACE,SAAS,SAAS,eAAe,UACjC,eAAe,MAAM,SAAS,UAAU,YAAY,SAAS,MAAM,EAAE,OAAO,GAE5E,OAAO,OAAO,sBAAsB,KAAK;KACvC;KACA,SAAS;IACX,CAAC;IAEH,MAAM,YAAY,SAAS,MAAM,SAAS,WAAW,OAAO,MAAM,iBAAiB,CAAC;IAEpF,IAAI,SAAS,WAAW,eAAe,QAAQ,OAAO,CAAC,SAAS,OAAO;IAEvE,MAAM,WAAW,CAAC,GAAG,QAAQ,QAAQ;IACrC,IAAI,eAAe,QAAQ;IAC3B,IAAI,aAAa,gBAAgB,OAAO;IACxC,IAAI,eAAe,QAAQ;IAE3B,KAAK,MAAM,SAAS,SAAS,MAAM,eAAe,MAAM,GAAG;KACzD,MAAM,SAAS,aAAa,KAAK;MAAE,OAAO;MAAc,SAAS,MAAM;KAAQ,CAAC;KAIhF,IAAI,SAAS,UAAU,qBACrB,OAAO,OAAO,oBAAoB,KAAK;MACrC;MACA,OAAO;MACP,YAAY;MACZ,eAAe,SAAS,SAAS;KACnC,CAAC;KAEH,MAAM,eAAe,eAAe,MAAM,OAAO;KAEjD,gBAAgB;KAChB,IAAI,eAAe,0BACjB,OAAO,OAAO,oBAAoB,KAAK;MACrC;MACA,OAAO;MACP,YAAY;MACZ,eAAe;KACjB,CAAC;KAEH,cAAc;KACd,IAAI,aAAa,yBACf,OAAO,OAAO,oBAAoB,KAAK;MACrC;MACA,OAAO;MACP,YAAY;MACZ,eAAe;KACjB,CAAC;KAEH,SAAS,KACP,cAAc,KAAK;MACjB;MACA,UAAU;MACV,GAAI,OAAO,UAAU,KAAA,IAAY,CAAC,IAAI,EAAE,OAAO,OAAO,MAAM;MAC5D,SAAS,OAAO;MAChB,cAAc;MACd;KACF,CAAC,CACH;KACA,gBAAgB;IAClB;IAEA,MAAM,WAAW,OAAO,KAAK;KAC3B,SAAS,QAAQ;KACjB;KACA;KACA;KACA;IACF,CAAC;IAED,OAAO,CAAC,UAAU,IAAI,IAAI,OAAO,CAAC,CAAC,IAAI,UAAU,QAAQ,CAAC;GAC5D,CAAC,CACH;EACF,CACF;EACA,WAAW,aACT,gBAAgB,IAAI,KAAK,CAAC,CAAC,KAAK,OAAO,SAAS,QAAQ,aAAa,KAAK,QAAQ,CAAC,CAAC;EACtF,SAAS,aACP,OAAO,IAAI,aAAa;GACtB,MAAM,WAAW,OAAO,aAAa,OAAO,gBAAgB,IAAI,KAAK,GAAG,QAAQ;GAEhF,OAAO,aAAa,KAAK;IACvB,QAAQ;IACR,YAAY,SAAS,MAAM,SAAS,WAAW,OAAO,MAAM,iBAAiB,CAAC;IAC9E;GACF,CAAC;EACH,CAAC;CACL,CAAC;AACH,CAAC,CACH"}

package/dist/core/ToolResult.d.mts

@@ -0,0 +1,2 @@
+import { a as applyToolResultBounds, i as UnserializableToolResult, o as unserializableToolResult, r as TruncatedToolResult, t as ToolResultBounds } from "../ToolResult-DmmgoChv.mjs";
+export { ToolResultBounds, TruncatedToolResult, UnserializableToolResult, applyToolResultBounds, unserializableToolResult };

package/dist/core/ToolResult.mjs

@@ -0,0 +1,140 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { n as utf8ByteLength, t as codePointUtf8Length } from "../utf8-DchGZRBd.mjs";
+import * as Schema from "effect/Schema";
+//#region src/core/ToolResult.ts
+var ToolResult_exports = /* @__PURE__ */ __exportAll({
+	ToolResultBounds: () => ToolResultBounds,
+	TruncatedToolResult: () => TruncatedToolResult,
+	UnserializableToolResult: () => UnserializableToolResult,
+	applyToolResultBounds: () => applyToolResultBounds,
+	unserializableToolResult: () => unserializableToolResult
+});
+/**
+* The minimal `TruncatedToolResult` envelope (empty head/tail, a 16-digit
+* `originalBytes`) encodes to at most 81 UTF-8 bytes; 256 guarantees every
+* accepted bound fits the envelope plus some real content, so the bound is a
+* hard resource guard rather than a best-effort one.
+*/
+const ENVELOPE_FLOOR_BYTES = 256;
+/** Byte bound applied to one encoded application Tool result before it enters history. */
+var ToolResultBounds = class extends Schema.Class("ToolResultBounds")({ maxBytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(ENVELOPE_FLOOR_BYTES)) }) {};
+/**
+* Canonical envelope replacing an encoded Tool result that exceeded its
+* policy bounds. `head` and `tail` are an exact prefix and suffix of the
+* original encoded JSON text; the middle is dropped, never paraphrased.
+*/
+var TruncatedToolResult = class extends Schema.Class("TruncatedToolResult")({
+	truncatedToolResult: Schema.Literal(true),
+	originalBytes: Schema.Natural,
+	head: Schema.String,
+	tail: Schema.String
+}) {};
+/**
+* Canonical fail-closed sentinel replacing an encoded Tool result that could
+* not be JSON-serialized at all (cyclic value, BigInt, `undefined`, throwing
+* `toJSON`). The original value never enters history or durable records —
+* an unserializable value is unbounded by construction, so the bound seam
+* replaces it wholesale rather than passing it through (runtime spec §9).
+*/
+var UnserializableToolResult = class extends Schema.Class("UnserializableToolResult")({
+	unserializableToolResult: Schema.Literal(true),
+	reason: Schema.String.check(Schema.isMaxLength(256))
+}) {};
+/**
+* Build the encoded sentinel for a serialization failure. Total by
+* construction — the cause is untrusted (a hostile `toString` or an
+* accessor-backed `Error.message` can itself throw on this last-resort
+* path) — and byte-bound: the complete encoded sentinel stays within the
+* 256-byte `ToolResultBounds` schema floor, so it fits every accepted
+* policy without the caller re-applying bounds.
+*/
+const unserializableToolResult = (cause) => {
+	let reason;
+	try {
+		const message = cause instanceof Error ? cause.message : cause;
+		reason = typeof message === "string" ? message : String(message);
+	} catch {
+		reason = "unserializable value";
+	}
+	const build = (clipped) => Schema.encodeSync(UnserializableToolResult)(UnserializableToolResult.make({
+		unserializableToolResult: true,
+		reason: clipped
+	}));
+	let clipped = takePrefixWithinBytes(reason, 128);
+	let sentinel = build(clipped);
+	while (clipped.length > 0 && utf8ByteLength(JSON.stringify(sentinel)) > 256) {
+		const last = clipped.codePointAt(clipped.length - 1);
+		clipped = clipped.slice(0, clipped.length - (last !== void 0 && last > 65535 ? 2 : 1));
+		sentinel = build(clipped);
+	}
+	return sentinel;
+};
+const takePrefixWithinBytes = (value, maxBytes) => {
+	let bytes = 0;
+	let index = 0;
+	while (index < value.length) {
+		const codePoint = value.codePointAt(index) ?? 0;
+		const width = codePointUtf8Length(codePoint);
+		if (bytes + width > maxBytes) break;
+		bytes += width;
+		index += codePoint > 65535 ? 2 : 1;
+	}
+	return value.slice(0, index);
+};
+const takeSuffixWithinBytes = (value, maxBytes) => {
+	let bytes = 0;
+	let index = value.length;
+	while (index > 0) {
+		const unit = value.charCodeAt(index - 1);
+		const pairStart = unit >= 56320 && unit <= 57343 && index >= 2 ? index - 2 : index - 1;
+		const codePoint = value.codePointAt(pairStart) ?? 0;
+		const width = codePointUtf8Length(codePoint);
+		if (bytes + width > maxBytes) break;
+		bytes += width;
+		index = pairStart;
+	}
+	return value.slice(index);
+};
+/**
+* Bound one encoded Tool result to `bounds.maxBytes` UTF-8 bytes.
+*
+* Within bounds the input is returned unchanged. Over bounds the result is
+* the JSON-encoded `TruncatedToolResult` envelope preserving an exact prefix
+* and suffix of the input, split ~50/50 across the byte budget left after
+* the envelope's own overhead and shrunk deterministically until the encoded
+* envelope itself fits. Slicing never splits a UTF-16 surrogate pair, so the
+* envelope always re-encodes as valid JSON.
+*
+* The Schema-level 256-byte floor on `ToolResultBounds.maxBytes` guarantees
+* every accepted bound fits the minimal envelope (at most 81 bytes), so the
+* returned value never exceeds `maxBytes` for a decodable bound. The
+* minimal-envelope fallback below survives purely as defense in depth.
+*/
+const applyToolResultBounds = (encodedJson, bounds) => {
+	const originalBytes = utf8ByteLength(encodedJson);
+	if (originalBytes <= bounds.maxBytes) return encodedJson;
+	const render = (head, tail) => JSON.stringify(Schema.encodeSync(TruncatedToolResult)(TruncatedToolResult.make({
+		truncatedToolResult: true,
+		originalBytes,
+		head,
+		tail
+	})));
+	const minimal = render("", "");
+	const contentBudget = bounds.maxBytes - utf8ByteLength(minimal);
+	if (contentBudget <= 0) return minimal;
+	let headBudget = Math.floor(contentBudget / 2);
+	let tailBudget = contentBudget - headBudget;
+	for (;;) {
+		const output = render(takePrefixWithinBytes(encodedJson, headBudget), takeSuffixWithinBytes(encodedJson, tailBudget));
+		const outputBytes = utf8ByteLength(output);
+		if (outputBytes <= bounds.maxBytes) return output;
+		if (headBudget === 0 && tailBudget === 0) return minimal;
+		const shrink = Math.max(1, Math.ceil((outputBytes - bounds.maxBytes) / 2));
+		headBudget = Math.max(0, headBudget - shrink);
+		tailBudget = Math.max(0, tailBudget - shrink);
+	}
+};
+//#endregion
+export { ToolResultBounds, TruncatedToolResult, UnserializableToolResult, applyToolResultBounds, ToolResult_exports as t, unserializableToolResult };
+
+//# sourceMappingURL=ToolResult.mjs.map

package/dist/core/ToolResult.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolResult.mjs","names":[],"sources":["../../src/core/ToolResult.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\n\nimport { codePointUtf8Length, utf8ByteLength } from \"./internal/utf8.ts\";\n\n/**\n * The minimal `TruncatedToolResult` envelope (empty head/tail, a 16-digit\n * `originalBytes`) encodes to at most 81 UTF-8 bytes; 256 guarantees every\n * accepted bound fits the envelope plus some real content, so the bound is a\n * hard resource guard rather than a best-effort one.\n */\nconst ENVELOPE_FLOOR_BYTES = 256;\n\n/** Byte bound applied to one encoded application Tool result before it enters history. */\nexport class ToolResultBounds extends Schema.Class<ToolResultBounds>(\"ToolResultBounds\")({\n  maxBytes: Schema.Int.check(Schema.isGreaterThanOrEqualTo(ENVELOPE_FLOOR_BYTES)),\n}) {}\n\n/**\n * Canonical envelope replacing an encoded Tool result that exceeded its\n * policy bounds. `head` and `tail` are an exact prefix and suffix of the\n * original encoded JSON text; the middle is dropped, never paraphrased.\n */\nexport class TruncatedToolResult extends Schema.Class<TruncatedToolResult>(\"TruncatedToolResult\")({\n  truncatedToolResult: Schema.Literal(true),\n  originalBytes: Schema.Natural,\n  head: Schema.String,\n  tail: Schema.String,\n}) {}\n\n/**\n * Canonical fail-closed sentinel replacing an encoded Tool result that could\n * not be JSON-serialized at all (cyclic value, BigInt, `undefined`, throwing\n * `toJSON`). The original value never enters history or durable records —\n * an unserializable value is unbounded by construction, so the bound seam\n * replaces it wholesale rather than passing it through (runtime spec §9).\n */\nexport class UnserializableToolResult extends Schema.Class<UnserializableToolResult>(\n  \"UnserializableToolResult\",\n)({\n  unserializableToolResult: Schema.Literal(true),\n  reason: Schema.String.check(Schema.isMaxLength(256)),\n}) {}\n\n/**\n * Build the encoded sentinel for a serialization failure. Total by\n * construction — the cause is untrusted (a hostile `toString` or an\n * accessor-backed `Error.message` can itself throw on this last-resort\n * path) — and byte-bound: the complete encoded sentinel stays within the\n * 256-byte `ToolResultBounds` schema floor, so it fits every accepted\n * policy without the caller re-applying bounds.\n */\nexport const unserializableToolResult = (\n  cause: unknown,\n): typeof UnserializableToolResult.Encoded => {\n  let reason: string;\n\n  try {\n    const message = cause instanceof Error ? cause.message : cause;\n\n    reason = typeof message === \"string\" ? message : String(message);\n  } catch {\n    reason = \"unserializable value\";\n  }\n\n  const build = (clipped: string): typeof UnserializableToolResult.Encoded =>\n    Schema.encodeSync(UnserializableToolResult)(\n      UnserializableToolResult.make({\n        unserializableToolResult: true,\n        reason: clipped,\n      }),\n    );\n\n  // JSON escaping inflates bytes, so shrink by whole code points until the\n  // encoded sentinel fits the floor; the empty reason always fits.\n  let clipped = takePrefixWithinBytes(reason, 128);\n  let sentinel = build(clipped);\n\n  while (clipped.length > 0 && utf8ByteLength(JSON.stringify(sentinel)) > 256) {\n    const last = clipped.codePointAt(clipped.length - 1);\n\n    clipped = clipped.slice(0, clipped.length - (last !== undefined && last > 0xffff ? 2 : 1));\n    sentinel = build(clipped);\n  }\n\n  return sentinel;\n};\n\nconst takePrefixWithinBytes = (value: string, maxBytes: number): string => {\n  let bytes = 0;\n  let index = 0;\n\n  while (index < value.length) {\n    const codePoint = value.codePointAt(index) ?? 0;\n    const width = codePointUtf8Length(codePoint);\n\n    if (bytes + width > maxBytes) break;\n    bytes += width;\n    index += codePoint > 0xffff ? 2 : 1;\n  }\n\n  return value.slice(0, index);\n};\n\nconst takeSuffixWithinBytes = (value: string, maxBytes: number): string => {\n  let bytes = 0;\n  let index = value.length;\n\n  while (index > 0) {\n    const unit = value.charCodeAt(index - 1);\n    const isLowSurrogate = unit >= 0xdc00 && unit <= 0xdfff;\n    const pairStart = isLowSurrogate && index >= 2 ? index - 2 : index - 1;\n    const codePoint = value.codePointAt(pairStart) ?? 0;\n    const width = codePointUtf8Length(codePoint);\n\n    if (bytes + width > maxBytes) break;\n    bytes += width;\n    index = pairStart;\n  }\n\n  return value.slice(index);\n};\n\n/**\n * Bound one encoded Tool result to `bounds.maxBytes` UTF-8 bytes.\n *\n * Within bounds the input is returned unchanged. Over bounds the result is\n * the JSON-encoded `TruncatedToolResult` envelope preserving an exact prefix\n * and suffix of the input, split ~50/50 across the byte budget left after\n * the envelope's own overhead and shrunk deterministically until the encoded\n * envelope itself fits. Slicing never splits a UTF-16 surrogate pair, so the\n * envelope always re-encodes as valid JSON.\n *\n * The Schema-level 256-byte floor on `ToolResultBounds.maxBytes` guarantees\n * every accepted bound fits the minimal envelope (at most 81 bytes), so the\n * returned value never exceeds `maxBytes` for a decodable bound. The\n * minimal-envelope fallback below survives purely as defense in depth.\n */\nexport const applyToolResultBounds = (encodedJson: string, bounds: ToolResultBounds): string => {\n  const originalBytes = utf8ByteLength(encodedJson);\n\n  if (originalBytes <= bounds.maxBytes) return encodedJson;\n\n  const render = (head: string, tail: string): string =>\n    JSON.stringify(\n      Schema.encodeSync(TruncatedToolResult)(\n        TruncatedToolResult.make({ truncatedToolResult: true, originalBytes, head, tail }),\n      ),\n    );\n\n  const minimal = render(\"\", \"\");\n  const contentBudget = bounds.maxBytes - utf8ByteLength(minimal);\n\n  if (contentBudget <= 0) return minimal;\n  let headBudget = Math.floor(contentBudget / 2);\n  let tailBudget = contentBudget - headBudget;\n\n  for (;;) {\n    const head = takePrefixWithinBytes(encodedJson, headBudget);\n    const tail = takeSuffixWithinBytes(encodedJson, tailBudget);\n    const output = render(head, tail);\n    const outputBytes = utf8ByteLength(output);\n\n    if (outputBytes <= bounds.maxBytes) return output;\n    if (headBudget === 0 && tailBudget === 0) return minimal;\n    const shrink = Math.max(1, Math.ceil((outputBytes - bounds.maxBytes) / 2));\n\n    headBudget = Math.max(0, headBudget - shrink);\n    tailBudget = Math.max(0, tailBudget - shrink);\n  }\n};\n"],"mappings":"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"}

package/dist/core/Usage.d.mts

@@ -0,0 +1,2 @@
+import { _ as unknownRunTotals, a as ModelUsageGroup, c as RunUsageReport, d as UsageCompleteness, g as summarizeModelUsage, h as sumRunTotals, i as ModelResponseIdentity, l as RunUsageSummary, m as runTotalsFromSummary, n as InputTokenUsage, o as OutputTokenUsage, p as emptyRunTotals, r as ModelCallUsage, s as RunTotals, t as ChildRunUsage, u as UsageAggregationError } from "../Usage-Dx0aknfk.mjs";
+export { ChildRunUsage, InputTokenUsage, ModelCallUsage, ModelResponseIdentity, ModelUsageGroup, OutputTokenUsage, RunTotals, RunUsageReport, RunUsageSummary, UsageAggregationError, UsageCompleteness, emptyRunTotals, runTotalsFromSummary, sumRunTotals, summarizeModelUsage, unknownRunTotals };