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

package/dist/durable/OperationAuthorizer.mjs

@@ -0,0 +1,70 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { SubmissionId, ThreadId } from "../core/Identifiers.mjs";
+import { Principal } from "../core/Receipt.mjs";
+import { Context, Effect, Layer, Schema } from "effect";
+//#region src/durable/OperationAuthorizer.ts
+var OperationAuthorizer_exports = /* @__PURE__ */ __exportAll({
+	AuthorizedOperation: () => AuthorizedOperation,
+	OperationAuthorizationRequest: () => OperationAuthorizationRequest,
+	OperationAuthorizer: () => OperationAuthorizer,
+	OperationDenied: () => OperationDenied,
+	operationAuthorizerLayer: () => operationAuthorizerLayer,
+	possessionOperationAuthorizer: () => possessionOperationAuthorizer
+});
+/**
+* Administrative/observation operations submitted to authorization (P7 WP1; SEC-003/SEC-011,
+* DUR-017 "authenticated per-read authorization"). The union covers every operation the durable
+* runtime consults the authorizer for: canonical observation, settlement waits, aborts,
+* administration, and the two durable resolution paths.
+*/
+const AuthorizedOperation = Schema.Literals([
+	"observe",
+	"awaitSettlement",
+	"abort",
+	"explain",
+	"verify",
+	"retry",
+	"wake",
+	"scanObligations",
+	"resolveUnknown",
+	"resolveApproval"
+]);
+/**
+* One authorization question. `principal` is present only when the host authenticated a caller
+* identity and threaded it through — the framework never parses bearer tokens (SEC-001); absent
+* identity under the default authorizer keeps the pre-P7 service-possession behavior.
+*/
+var OperationAuthorizationRequest = class extends Schema.Class("@effect-agent/thread/OperationAuthorizationRequest")({
+	operation: AuthorizedOperation,
+	threadId: Schema.optionalKey(ThreadId),
+	submissionId: Schema.optionalKey(SubmissionId),
+	principal: Schema.optionalKey(Principal)
+}) {};
+/** A typed, fail-closed authorization denial (never a defect, never silent). */
+var OperationDenied = class extends Schema.TaggedError()("OperationDenied", {
+	operation: AuthorizedOperation,
+	reason: Schema.String.check(Schema.isMaxLength(4096)),
+	threadId: Schema.optionalKey(ThreadId),
+	submissionId: Schema.optionalKey(SubmissionId)
+}) {};
+/**
+* The default possession-behavior authorizer: possession of the `DurableAgentRuntime` service
+* (plus each mutating command's mandatory author/reason audit fields) IS the authorization —
+* exactly the pre-P7 boundary, unchanged. Hosts that authenticate callers substitute a real
+* decision procedure through `operationAuthorizerLayer`; the framework enforces the decision
+* fail-closed without inventing an identity system (D10/DUR-017 stance, plan §3).
+*/
+const possessionOperationAuthorizer = { authorize: () => Effect.void };
+/**
+* Context reference with the possession default, mirroring `DurableApprovalResolver`: the
+* coordinator consults it unconditionally, and only a host-supplied non-default Layer changes
+* the answer. References resolve at Layer construction, so provide the override when building
+* `DurableAgentRuntime.layer` (e.g. `Layer.provide(operationAuthorizerLayer(...))`).
+*/
+const OperationAuthorizer = Context.Reference("@effect-agent/thread/OperationAuthorizer", { defaultValue: () => possessionOperationAuthorizer });
+/** Layer carrying a host-supplied authorization decision procedure. */
+const operationAuthorizerLayer = (service) => Layer.succeedContext(Context.make(OperationAuthorizer, service));
+//#endregion
+export { AuthorizedOperation, OperationAuthorizationRequest, OperationAuthorizer, OperationDenied, operationAuthorizerLayer, possessionOperationAuthorizer, OperationAuthorizer_exports as t };
+
+//# sourceMappingURL=OperationAuthorizer.mjs.map

package/dist/durable/OperationAuthorizer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationAuthorizer.mjs","names":[],"sources":["../../src/durable/OperationAuthorizer.ts"],"sourcesContent":["import { Context, Effect, Layer, Schema } from \"effect\";\n\nimport { ThreadId, SubmissionId } from \"../core/Identifiers.ts\";\nimport { Principal } from \"./SubmissionLedger.ts\";\n\n/**\n * Administrative/observation operations submitted to authorization (P7 WP1; SEC-003/SEC-011,\n * DUR-017 \"authenticated per-read authorization\"). The union covers every operation the durable\n * runtime consults the authorizer for: canonical observation, settlement waits, aborts,\n * administration, and the two durable resolution paths.\n */\nexport const AuthorizedOperation = Schema.Literals([\n  \"observe\",\n  \"awaitSettlement\",\n  \"abort\",\n  \"explain\",\n  \"verify\",\n  \"retry\",\n  \"wake\",\n  \"scanObligations\",\n  \"resolveUnknown\",\n  \"resolveApproval\",\n]);\n\nexport type AuthorizedOperation = typeof AuthorizedOperation.Type;\n\n/**\n * One authorization question. `principal` is present only when the host authenticated a caller\n * identity and threaded it through — the framework never parses bearer tokens (SEC-001); absent\n * identity under the default authorizer keeps the pre-P7 service-possession behavior.\n */\nexport class OperationAuthorizationRequest extends Schema.Class<OperationAuthorizationRequest>(\n  \"@effect-agent/thread/OperationAuthorizationRequest\",\n)({\n  operation: AuthorizedOperation,\n  threadId: Schema.optionalKey(ThreadId),\n  submissionId: Schema.optionalKey(SubmissionId),\n  principal: Schema.optionalKey(Principal),\n}) {}\n\n/** A typed, fail-closed authorization denial (never a defect, never silent). */\nexport class OperationDenied extends Schema.TaggedError<OperationDenied>()(\"OperationDenied\", {\n  operation: AuthorizedOperation,\n  reason: Schema.String.check(Schema.isMaxLength(4_096)),\n  threadId: Schema.optionalKey(ThreadId),\n  submissionId: Schema.optionalKey(SubmissionId),\n}) {}\n\n/**\n * The minimal authorization port consulted by `observe`, `awaitSettlement`, `abort`, administration, and the\n * `resolveUnknown`/`resolveApproval` resolution paths. `authorize` either succeeds (allow) or\n * fails with the typed `OperationDenied` (deny) — the runtime propagates the denial fail-closed\n * and performs no reads or writes for the denied operation.\n */\nexport interface OperationAuthorizerService {\n  readonly authorize: (\n    request: OperationAuthorizationRequest,\n  ) => Effect.Effect<void, OperationDenied>;\n}\n\n/**\n * The default possession-behavior authorizer: possession of the `DurableAgentRuntime` service\n * (plus each mutating command's mandatory author/reason audit fields) IS the authorization —\n * exactly the pre-P7 boundary, unchanged. Hosts that authenticate callers substitute a real\n * decision procedure through `operationAuthorizerLayer`; the framework enforces the decision\n * fail-closed without inventing an identity system (D10/DUR-017 stance, plan §3).\n */\nexport const possessionOperationAuthorizer: OperationAuthorizerService = {\n  authorize: () => Effect.void,\n};\n\n/**\n * Context reference with the possession default, mirroring `DurableApprovalResolver`: the\n * coordinator consults it unconditionally, and only a host-supplied non-default Layer changes\n * the answer. References resolve at Layer construction, so provide the override when building\n * `DurableAgentRuntime.layer` (e.g. `Layer.provide(operationAuthorizerLayer(...))`).\n */\nexport const OperationAuthorizer: Context.Reference<OperationAuthorizerService> =\n  Context.Reference<OperationAuthorizerService>(\"@effect-agent/thread/OperationAuthorizer\", {\n    defaultValue: () => possessionOperationAuthorizer,\n  });\n\n/** Layer carrying a host-supplied authorization decision procedure. */\nexport const operationAuthorizerLayer = (service: OperationAuthorizerService): Layer.Layer<never> =>\n  Layer.succeedContext(Context.make(OperationAuthorizer, service));\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAWA,MAAa,sBAAsB,OAAO,SAAS;CACjD;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;AASD,IAAa,gCAAb,cAAmD,OAAO,MACxD,oDACF,CAAC,CAAC;CACA,WAAW;CACX,UAAU,OAAO,YAAY,QAAQ;CACrC,cAAc,OAAO,YAAY,YAAY;CAC7C,WAAW,OAAO,YAAY,SAAS;AACzC,CAAC,CAAC,CAAC,CAAC;;AAGJ,IAAa,kBAAb,cAAqC,OAAO,YAA6B,CAAC,CAAC,mBAAmB;CAC5F,WAAW;CACX,QAAQ,OAAO,OAAO,MAAM,OAAO,YAAY,IAAK,CAAC;CACrD,UAAU,OAAO,YAAY,QAAQ;CACrC,cAAc,OAAO,YAAY,YAAY;AAC/C,CAAC,CAAC,CAAC,CAAC;;;;;;;;AAqBJ,MAAa,gCAA4D,EACvE,iBAAiB,OAAO,KAC1B;;;;;;;AAQA,MAAa,sBACX,QAAQ,UAAsC,4CAA4C,EACxF,oBAAoB,8BACtB,CAAC;;AAGH,MAAa,4BAA4B,YACvC,MAAM,eAAe,QAAQ,KAAK,qBAAqB,OAAO,CAAC"}

package/dist/durable/PersistentHistory.d.mts

@@ -0,0 +1,16 @@
+import { t as ThreadHistory } from "../ThreadHistory-tS1KwxHR.mjs";
+import { nn as ThreadStore } from "../Records-BAGkekt8.mjs";
+import { Layer } from "effect";
+declare namespace PersistentHistory_d_exports {
+  export { layer };
+}
+/**
+ * Provide retained history to the normal AgentRuntime entry points. Each successful Run appends
+ * one three-record batch. Staging is private to that Run; interruption discards it. Epoch zero
+ * and the loaded tail fence stale writers without replaying external execution. A storage failure
+ * after append may leave the whole Run recorded. Adapter failpoints cover both durable mutations.
+ */
+declare const layer: Layer.Layer<ThreadHistory, never, ThreadStore>;
+//#endregion
+export { layer, PersistentHistory_d_exports as t };
+//# sourceMappingURL=PersistentHistory.d.mts.map

package/dist/durable/PersistentHistory.mjs

@@ -0,0 +1,125 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ThreadHistory, ThreadHistoryError } from "../engine/ThreadHistory.mjs";
+import { BatchId, CanonicalBatch, DeploymentId, ModelCompleted, PersistedJson, ProducerEpoch, ProducerId, RecordEnvelope, RecordId, RunCompleted, UserInputRecorded } from "./Records.mjs";
+import { FencedAppendRequest, MAX_THREAD_EXPORT_RECORDS, ThreadExportRequest, ThreadMaterialization, ThreadStore } from "./ThreadStore.mjs";
+import { m as promptFromCanonicalRecords } from "../RunJournal-Cgg1kNvc.mjs";
+import { Prompt } from "effect/unstable/ai";
+import { DateTime, Effect, Layer, Schema } from "effect";
+//#region src/durable/PersistentHistory.ts
+var PersistentHistory_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
+const HISTORY_EPOCH = Schema.decodeSync(ProducerEpoch)(0);
+const HISTORY_DEPLOYMENT = Schema.decodeSync(DeploymentId)("persistent-history");
+const batchId = Schema.decodeSync(BatchId);
+const producer = Schema.decodeSync(ProducerId);
+const recordId = Schema.decodeSync(RecordId);
+const historyError = (threadId, reason, message, cause) => ThreadHistoryError.make({
+	threadId,
+	reason,
+	message,
+	...cause === void 0 ? {} : { cause }
+});
+const storageError = (threadId, cause) => historyError(threadId, cause._tag === "AppendConflict" ? "conflict" : cause._tag === "FenceRejected" ? "fenced" : cause._tag === "ThreadNotMaterialized" ? "not-found" : "storage", cause._tag === "ThreadStoreError" ? cause.message : cause._tag, cause);
+/**
+* Provide retained history to the normal AgentRuntime entry points. Each successful Run appends
+* one three-record batch. Staging is private to that Run; interruption discards it. Epoch zero
+* and the loaded tail fence stale writers without replaying external execution. A storage failure
+* after append may leave the whole Run recorded. Adapter failpoints cover both durable mutations.
+*/
+const layer = Layer.effect(ThreadHistory, Effect.gen(function* () {
+	const store = yield* ThreadStore;
+	const load = Effect.fn("PersistentHistory.load")(function* (threadId) {
+		const exported = yield* store.export(ThreadExportRequest.make({ threadId })).pipe(Effect.mapError((cause) => storageError(threadId, cause)));
+		return yield* promptFromCanonicalRecords(exported.records).pipe(Effect.mapError((cause) => historyError(threadId, "encoding", cause.message, cause)));
+	});
+	const open = Effect.fn("PersistentHistory.open")(function* ({ threadId, runId }) {
+		const error = (reason, message, cause) => historyError(threadId, reason, message, cause);
+		const persisted = (value) => Schema.decodeUnknownEffect(PersistedJson)(value).pipe(Effect.mapError((cause) => error("limit", "Run data exceeds canonical persistence bounds", cause)));
+		yield* store.materialize(ThreadMaterialization.make({
+			threadId,
+			producerEpoch: HISTORY_EPOCH
+		})).pipe(Effect.mapError((cause) => storageError(threadId, cause)));
+		const base = yield* store.export(ThreadExportRequest.make({ threadId })).pipe(Effect.mapError((cause) => storageError(threadId, cause)));
+		if (base.records.length + 3 > 131072) return yield* error("limit", `This Run would exceed the history limit of ${MAX_THREAD_EXPORT_RECORDS} records; use a new Thread`);
+		if (base.records.some(({ record }) => record.payload._tag === "UserInputRecorded" && record.payload.submissionId !== void 0 || record.payload._tag === "SubmissionSettled" || record.payload._tag === "AbortRequested")) return yield* error("incompatible", "This Thread belongs to durable accepted work; use a separate history Thread");
+		const prompt = yield* promptFromCanonicalRecords(base.records).pipe(Effect.mapError((cause) => error("encoding", cause.message, cause)));
+		const expectedTailSequence = base.tailSequence;
+		const expectedTailDigest = base.tailDigest;
+		const initialPromptLength = prompt.content.length;
+		const createdAt = yield* DateTime.now;
+		const record = (id, payload, timestamp = createdAt) => RecordEnvelope.make({
+			recordId: recordId(id),
+			family: "thread",
+			schemaVersion: 1,
+			deploymentId: HISTORY_DEPLOYMENT,
+			createdAt: timestamp,
+			payload
+		});
+		let input;
+		let messages;
+		let stagedSource = [];
+		let encodedMessages = [];
+		return {
+			prompt,
+			stageInput: Effect.fn("PersistentHistory.stageInput")(function* (encodedInput) {
+				input = record(`history-input:${runId}`, UserInputRecorded.make({
+					kind: "user",
+					runId,
+					input: yield* persisted(encodedInput)
+				}));
+			}),
+			stageHistory: Effect.fn("PersistentHistory.stageHistory")(function* (next) {
+				const source = next.content.slice(initialPromptLength);
+				let retained = 0;
+				while (retained < source.length && retained < stagedSource.length && source[retained] === stagedSource[retained]) retained++;
+				const suffix = yield* Schema.encodeEffect(Prompt.Prompt)(Prompt.fromMessages(source.slice(retained))).pipe(Effect.mapError((cause) => error("encoding", "Run history could not be encoded", cause)));
+				const nextEncoded = [...encodedMessages.slice(0, retained), ...suffix.content];
+				messages = yield* persisted({ content: nextEncoded });
+				encodedMessages = nextEncoded;
+				stagedSource = source;
+			}),
+			commit: Effect.fn("PersistentHistory.commit")(function* (completion) {
+				if (input === void 0 || messages === void 0) return yield* error("encoding", "Run completed without its encoded input and history");
+				const output = yield* persisted(completion.output);
+				const runDisposition = completion.runDisposition === void 0 ? void 0 : yield* persisted(completion.runDisposition);
+				const completedAt = yield* DateTime.now;
+				const modelCompleted = yield* ModelCompleted.makeEffect({
+					runId,
+					output,
+					messages
+				}).pipe(Effect.mapError((cause) => error("encoding", "Run history is not a canonical Prompt", cause)));
+				yield* store.append(FencedAppendRequest.make({
+					threadId,
+					producerEpoch: HISTORY_EPOCH,
+					expectedTailSequence,
+					expectedTailDigest,
+					batch: CanonicalBatch.make({
+						batchId: batchId(`history:${runId}`),
+						producerId: producer(`history:${runId}`),
+						records: [
+							input,
+							record(`history-output:${runId}`, modelCompleted, completedAt),
+							record(`run-completed:${runId}`, RunCompleted.make({
+								runId,
+								output,
+								...runDisposition === void 0 ? {} : { runDisposition },
+								...completion.finishReason === "budget-exhausted" ? {
+									finishReason: completion.finishReason,
+									exhausted: completion.exhausted
+								} : {}
+							}), completedAt)
+						]
+					})
+				})).pipe(Effect.mapError((cause) => storageError(threadId, cause)));
+			})
+		};
+	});
+	return ThreadHistory.of({
+		retention: "on-success",
+		load,
+		open
+	});
+}));
+//#endregion
+export { layer, PersistentHistory_exports as t };
+
+//# sourceMappingURL=PersistentHistory.mjs.map

package/dist/durable/PersistentHistory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistentHistory.mjs","names":[],"sources":["../../src/durable/PersistentHistory.ts"],"sourcesContent":["import { DateTime, Effect, Layer, Schema } from \"effect\";\nimport { Prompt } from \"effect/unstable/ai\";\n\nimport { type ThreadId, type RunId } from \"../core/Identifiers.ts\";\nimport { type RunCompleted as RunCompletedEvent } from \"../core/RunEvent.ts\";\nimport {\n  ThreadHistory,\n  ThreadHistoryError,\n  type ThreadHistoryRun,\n} from \"../engine/ThreadHistory.ts\";\nimport {\n  BatchId,\n  CanonicalBatch,\n  DeploymentId,\n  ModelCompleted,\n  PersistedJson,\n  ProducerEpoch,\n  ProducerId,\n  RecordEnvelope,\n  RecordId,\n  RunCompleted,\n  UserInputRecorded,\n} from \"./Records.ts\";\nimport { promptFromCanonicalRecords } from \"./RunJournal.ts\";\nimport {\n  ThreadExportRequest,\n  ThreadMaterialization,\n  ThreadStore,\n  FencedAppendRequest,\n  MAX_THREAD_EXPORT_RECORDS,\n  type ThreadStoreFailure,\n} from \"./ThreadStore.ts\";\n\nconst HISTORY_EPOCH = Schema.decodeSync(ProducerEpoch)(0);\nconst HISTORY_DEPLOYMENT = Schema.decodeSync(DeploymentId)(\"persistent-history\");\nconst batchId = Schema.decodeSync(BatchId);\nconst producer = Schema.decodeSync(ProducerId);\nconst recordId = Schema.decodeSync(RecordId);\n\nconst historyError = (\n  threadId: ThreadId,\n  reason: ThreadHistoryError[\"reason\"],\n  message: string,\n  cause?: unknown,\n) =>\n  ThreadHistoryError.make({\n    threadId,\n    reason,\n    message,\n    ...(cause === undefined ? {} : { cause }),\n  });\n\nconst storageError = (threadId: ThreadId, cause: ThreadStoreFailure) =>\n  historyError(\n    threadId,\n    cause._tag === \"AppendConflict\"\n      ? \"conflict\"\n      : cause._tag === \"FenceRejected\"\n        ? \"fenced\"\n        : cause._tag === \"ThreadNotMaterialized\"\n          ? \"not-found\"\n          : \"storage\",\n    cause._tag === \"ThreadStoreError\" ? cause.message : cause._tag,\n    cause,\n  );\n\n/**\n * Provide retained history to the normal AgentRuntime entry points. Each successful Run appends\n * one three-record batch. Staging is private to that Run; interruption discards it. Epoch zero\n * and the loaded tail fence stale writers without replaying external execution. A storage failure\n * after append may leave the whole Run recorded. Adapter failpoints cover both durable mutations.\n */\nexport const layer = Layer.effect(\n  ThreadHistory,\n  Effect.gen(function* () {\n    const store = yield* ThreadStore;\n\n    const load = Effect.fn(\"PersistentHistory.load\")(function* (threadId: ThreadId) {\n      const exported = yield* store\n        .export(ThreadExportRequest.make({ threadId }))\n        .pipe(Effect.mapError((cause) => storageError(threadId, cause)));\n\n      return yield* promptFromCanonicalRecords(exported.records).pipe(\n        Effect.mapError((cause) => historyError(threadId, \"encoding\", cause.message, cause)),\n      );\n    });\n\n    const open = Effect.fn(\"PersistentHistory.open\")(function* ({\n      threadId,\n      runId,\n    }: {\n      readonly threadId: ThreadId;\n      readonly runId: RunId;\n    }): Effect.fn.Return<ThreadHistoryRun, ThreadHistoryError> {\n      const error = (reason: ThreadHistoryError[\"reason\"], message: string, cause?: unknown) =>\n        historyError(threadId, reason, message, cause);\n\n      const persisted = (value: unknown) =>\n        Schema.decodeUnknownEffect(PersistedJson)(value).pipe(\n          Effect.mapError((cause) =>\n            error(\"limit\", \"Run data exceeds canonical persistence bounds\", cause),\n          ),\n        );\n\n      yield* store\n        .materialize(ThreadMaterialization.make({ threadId, producerEpoch: HISTORY_EPOCH }))\n        .pipe(Effect.mapError((cause) => storageError(threadId, cause)));\n\n      const base = yield* store\n        .export(ThreadExportRequest.make({ threadId }))\n        .pipe(Effect.mapError((cause) => storageError(threadId, cause)));\n\n      if (base.records.length + 3 > MAX_THREAD_EXPORT_RECORDS) {\n        return yield* error(\n          \"limit\",\n          `This Run would exceed the history limit of ${MAX_THREAD_EXPORT_RECORDS} records; use a new Thread`,\n        );\n      }\n      if (\n        base.records.some(\n          ({ record }) =>\n            (record.payload._tag === \"UserInputRecorded\" &&\n              record.payload.submissionId !== undefined) ||\n            record.payload._tag === \"SubmissionSettled\" ||\n            record.payload._tag === \"AbortRequested\",\n        )\n      ) {\n        return yield* error(\n          \"incompatible\",\n          \"This Thread belongs to durable accepted work; use a separate history Thread\",\n        );\n      }\n\n      const prompt = yield* promptFromCanonicalRecords(base.records).pipe(\n        Effect.mapError((cause) => error(\"encoding\", cause.message, cause)),\n      );\n\n      const expectedTailSequence = base.tailSequence;\n      const expectedTailDigest = base.tailDigest;\n      const initialPromptLength = prompt.content.length;\n\n      const createdAt = yield* DateTime.now;\n\n      const record = (id: string, payload: RecordEnvelope[\"payload\"], timestamp = createdAt) =>\n        RecordEnvelope.make({\n          recordId: recordId(id),\n          family: \"thread\",\n          schemaVersion: 1,\n          deploymentId: HISTORY_DEPLOYMENT,\n          createdAt: timestamp,\n          payload,\n        });\n\n      let input: RecordEnvelope | undefined;\n      let messages: PersistedJson | undefined;\n      let stagedSource: ReadonlyArray<Prompt.Message> = [];\n      let encodedMessages: ReadonlyArray<Prompt.MessageEncoded> = [];\n\n      return {\n        prompt,\n        stageInput: Effect.fn(\"PersistentHistory.stageInput\")(function* (encodedInput: unknown) {\n          input = record(\n            `history-input:${runId}`,\n            UserInputRecorded.make({\n              kind: \"user\",\n              runId,\n              input: yield* persisted(encodedInput),\n            }),\n          );\n        }),\n        stageHistory: Effect.fn(\"PersistentHistory.stageHistory\")(function* (next: Prompt.Prompt) {\n          const source = next.content.slice(initialPromptLength);\n          let retained = 0;\n\n          while (\n            retained < source.length &&\n            retained < stagedSource.length &&\n            source[retained] === stagedSource[retained]\n          ) {\n            retained++;\n          }\n\n          // Normal engine updates append messages. Rewritten or shortened histories retain only\n          // their unchanged prefix, so direct staging callers keep the same replacement behavior.\n          const suffix = yield* Schema.encodeEffect(Prompt.Prompt)(\n            Prompt.fromMessages(source.slice(retained)),\n          ).pipe(\n            Effect.mapError((cause) =>\n              error(\"encoding\", \"Run history could not be encoded\", cause),\n            ),\n          );\n\n          const nextEncoded = [...encodedMessages.slice(0, retained), ...suffix.content];\n          const nextMessages = yield* persisted({ content: nextEncoded });\n\n          // Aggregate validation stays at every history update: per-message limits would admit\n          // oversized Runs and move failures past the next model or Tool call.\n          messages = nextMessages;\n          encodedMessages = nextEncoded;\n          stagedSource = source;\n        }),\n        commit: Effect.fn(\"PersistentHistory.commit\")(function* (completion: RunCompletedEvent) {\n          if (input === undefined || messages === undefined) {\n            return yield* error(\"encoding\", \"Run completed without its encoded input and history\");\n          }\n          const output = yield* persisted(completion.output);\n\n          const runDisposition =\n            completion.runDisposition === undefined\n              ? undefined\n              : yield* persisted(completion.runDisposition);\n\n          const completedAt = yield* DateTime.now;\n\n          const modelCompleted = yield* ModelCompleted.makeEffect({ runId, output, messages }).pipe(\n            Effect.mapError((cause) =>\n              error(\"encoding\", \"Run history is not a canonical Prompt\", cause),\n            ),\n          );\n\n          yield* store\n            .append(\n              FencedAppendRequest.make({\n                threadId,\n                producerEpoch: HISTORY_EPOCH,\n                expectedTailSequence,\n                expectedTailDigest,\n                batch: CanonicalBatch.make({\n                  batchId: batchId(`history:${runId}`),\n                  producerId: producer(`history:${runId}`),\n                  records: [\n                    input,\n                    record(`history-output:${runId}`, modelCompleted, completedAt),\n                    record(\n                      `run-completed:${runId}`,\n                      RunCompleted.make({\n                        runId,\n                        output,\n                        ...(runDisposition === undefined ? {} : { runDisposition }),\n                        ...(completion.finishReason === \"budget-exhausted\"\n                          ? {\n                              finishReason: completion.finishReason,\n                              exhausted: completion.exhausted,\n                            }\n                          : {}),\n                      }),\n                      completedAt,\n                    ),\n                  ],\n                }),\n              }),\n            )\n            .pipe(Effect.mapError((cause) => storageError(threadId, cause)));\n        }),\n      };\n    });\n\n    return ThreadHistory.of({ retention: \"on-success\", load, open });\n  }),\n);\n"],"mappings":"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"}

package/dist/durable/PreparedInputAdmission.d.mts

@@ -0,0 +1,2 @@
+import { r as admitPreparedInput, t as PreparedInputAdmission } from "../PreparedInputAdmission-C4HbjHgl.mjs";
+export { PreparedInputAdmission, admitPreparedInput };

package/dist/durable/PreparedInputAdmission.mjs

@@ -0,0 +1,34 @@
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { ScheduleStorageError } from "./Schedule.mjs";
+import { Context, Effect } from "effect";
+//#region src/durable/PreparedInputAdmission.ts
+var PreparedInputAdmission_exports = /* @__PURE__ */ __exportAll({
+	PreparedInputAdmission: () => PreparedInputAdmission,
+	admitPreparedInput: () => admitPreparedInput
+});
+/** Host admission shared by event deliveries and scheduling adapters. */
+var PreparedInputAdmission = class extends Context.Service()("@effect-agent/thread/PreparedInputAdmission") {};
+/**
+* Reduce one bounded admission attempt. The caller owns concurrency, durable retry state,
+* and completion fencing. Interruption and defects propagate without claiming a refusal.
+*/
+const admitPreparedInput = Effect.fn("Thread.admitPreparedInput")((submit, timeoutMillis) => submit.pipe(Effect.timeout(timeoutMillis), Effect.map((receipt) => ({
+	_tag: "Receipt",
+	receipt
+})), Effect.catchTag("ScheduledInputRefused", (error) => Effect.succeed({
+	_tag: "Refused",
+	error
+})), Effect.catchTag("ScheduledInputRetryable", (error) => Effect.succeed({
+	_tag: "Retry",
+	reason: error.reason
+})), Effect.catchTag("TimeoutError", () => Effect.succeed({
+	_tag: "Retry",
+	reason: "timeout"
+})), Effect.catchTag("ScheduleStorageError", (error) => error.reason === "unavailable" ? Effect.succeed({
+	_tag: "Retry",
+	reason: "storage"
+}) : Effect.fail(ScheduleStorageError.make(error)))));
+//#endregion
+export { PreparedInputAdmission, admitPreparedInput, PreparedInputAdmission_exports as t };
+
+//# sourceMappingURL=PreparedInputAdmission.mjs.map

package/dist/durable/PreparedInputAdmission.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreparedInputAdmission.mjs","names":[],"sources":["../../src/durable/PreparedInputAdmission.ts"],"sourcesContent":["import { Context, Effect } from \"effect\";\n\nimport type { Receipt } from \"./DurableAgentRuntime.ts\";\nimport { type ScheduledInputFailure, ScheduleStorageError } from \"./Schedule.ts\";\nimport type { SubmissionStatus } from \"./SubmissionStatus.ts\";\nimport type { PreparedInput } from \"./Subscription.ts\";\n\n/** Host admission shared by event deliveries and scheduling adapters. */\nexport class PreparedInputAdmission extends Context.Service<\n  PreparedInputAdmission,\n  {\n    /** Required when retention is configured; reports canonical settlement without releasing group ownership itself. */\n    readonly submissionStatus?: (\n      receipt: Receipt,\n    ) => Effect.Effect<SubmissionStatus, ScheduledInputFailure>;\n    readonly submit: (envelope: PreparedInput) => Effect.Effect<Receipt, ScheduledInputFailure>;\n  }\n>()(\"@effect-agent/thread/PreparedInputAdmission\") {}\n\n/**\n * Reduce one bounded admission attempt. The caller owns concurrency, durable retry state,\n * and completion fencing. Interruption and defects propagate without claiming a refusal.\n */\nexport const admitPreparedInput = Effect.fn(\"Thread.admitPreparedInput\")(\n  <R>(submit: Effect.Effect<Receipt, ScheduledInputFailure, R>, timeoutMillis: number) =>\n    submit.pipe(\n      Effect.timeout(timeoutMillis),\n      Effect.map((receipt) => ({ _tag: \"Receipt\" as const, receipt })),\n      Effect.catchTag(\"ScheduledInputRefused\", (error) =>\n        Effect.succeed({ _tag: \"Refused\" as const, error }),\n      ),\n      Effect.catchTag(\"ScheduledInputRetryable\", (error) =>\n        Effect.succeed({ _tag: \"Retry\" as const, reason: error.reason }),\n      ),\n      Effect.catchTag(\"TimeoutError\", () =>\n        Effect.succeed({ _tag: \"Retry\" as const, reason: \"timeout\" as const }),\n      ),\n      Effect.catchTag(\"ScheduleStorageError\", (error) =>\n        error.reason === \"unavailable\"\n          ? Effect.succeed({ _tag: \"Retry\" as const, reason: \"storage\" as const })\n          : Effect.fail(ScheduleStorageError.make(error)),\n      ),\n    ),\n);\n"],"mappings":";;;;;;;;;AAQA,IAAa,yBAAb,cAA4C,QAAQ,QASlD,CAAC,CAAC,6CAA6C,CAAC,CAAC,CAAC;;;;;AAMpD,MAAa,qBAAqB,OAAO,GAAG,2BAA2B,CAAC,EAClE,QAA0D,kBAC5D,OAAO,KACL,OAAO,QAAQ,aAAa,GAC5B,OAAO,KAAK,aAAa;CAAE,MAAM;CAAoB;AAAQ,EAAE,GAC/D,OAAO,SAAS,0BAA0B,UACxC,OAAO,QAAQ;CAAE,MAAM;CAAoB;AAAM,CAAC,CACpD,GACA,OAAO,SAAS,4BAA4B,UAC1C,OAAO,QAAQ;CAAE,MAAM;CAAkB,QAAQ,MAAM;AAAO,CAAC,CACjE,GACA,OAAO,SAAS,sBACd,OAAO,QAAQ;CAAE,MAAM;CAAkB,QAAQ;AAAmB,CAAC,CACvE,GACA,OAAO,SAAS,yBAAyB,UACvC,MAAM,WAAW,gBACb,OAAO,QAAQ;CAAE,MAAM;CAAkB,QAAQ;AAAmB,CAAC,IACrE,OAAO,KAAK,qBAAqB,KAAK,KAAK,CAAC,CAClD,CACF,CACJ"}

package/dist/durable/Records.d.mts

@@ -0,0 +1,2 @@
+import { $ as ToolCallResolved, A as ProducerId, B as SettlementOutcome, C as ModelCompleted, D as PeerMessagePrepared, E as ObservationOffset, F as RunCompleted, G as SubmissionSettled, H as SubagentLineageRecorded, I as RunFailed, J as ThreadCreated, K as SubmissionSettledRecord, L as RunPolicyUsageReserved, M as RecordId, O as PersistedJson, P as RepairAnnotated, Q as ToolCallResolution, R as RunStartedRecord, S as MAX_PERSISTED_JSON_NODES, T as ModelResponseRecorded, U as SubagentRequested, V as SubagentJoined, W as SubagentStarted, X as ToolApprovalRequested, Y as ToolApprovalDecided, Z as ToolCallPrepared, _ as Digest, a as BatchId, at as WorkerInputCompleted, b as MAX_PERSISTED_JSON_COLLECTION_LENGTH, c as CanonicalRecord, ct as WorkerOriginRecorded, d as CanonicalSequence, dt as WorkerReportingIntent, et as ToolCallSettled, f as CompactionCreated, g as DeploymentId, h as DefinitionDigests, i as ApprovalDecision, it as WorkerAdmission, j as RecordEnvelope, k as ProducerEpoch, l as CanonicalRecordEnvelope, lt as WorkerReportPrepared, m as DefinitionDigestInput, n as AbortedSubmissionSettled, nt as ToolStepSettled, o as CURRENT_CANONICAL_SCHEMA_VERSION, ot as WorkerInputRequested, p as CompletedSubmissionSettled, q as SubtreeBudgetReserved, r as AgentUpdateEmitted, rt as UserInputRecorded, s as CanonicalBatch, st as WorkerOrigin, t as AbortRequested, tt as ToolCallUnknown, u as CanonicalRecordPayload, ut as WorkerReportRefused, v as FailedSubmissionSettled, w as ModelResponseInterrupted, x as MAX_PERSISTED_JSON_DEPTH, y as MAX_PERSISTED_JSON_BYTES, z as SettlementFailureDiagnostic } from "../Records-BAGkekt8.mjs";
+export { AbortRequested, AbortedSubmissionSettled, AgentUpdateEmitted, ApprovalDecision, BatchId, CURRENT_CANONICAL_SCHEMA_VERSION, CanonicalBatch, CanonicalRecord, CanonicalRecordEnvelope, CanonicalRecordPayload, CanonicalSequence, CompactionCreated, CompletedSubmissionSettled, DefinitionDigestInput, DefinitionDigests, DeploymentId, Digest, FailedSubmissionSettled, MAX_PERSISTED_JSON_BYTES, MAX_PERSISTED_JSON_COLLECTION_LENGTH, MAX_PERSISTED_JSON_DEPTH, MAX_PERSISTED_JSON_NODES, ModelCompleted, ModelResponseInterrupted, ModelResponseRecorded, ObservationOffset, PeerMessagePrepared, PersistedJson, ProducerEpoch, ProducerId, RecordEnvelope, RecordId, RepairAnnotated, RunCompleted, RunFailed, RunPolicyUsageReserved, RunStartedRecord, SettlementFailureDiagnostic, SettlementOutcome, SubagentJoined, SubagentLineageRecorded, SubagentRequested, SubagentStarted, SubmissionSettled, SubmissionSettledRecord, SubtreeBudgetReserved, ThreadCreated, ToolApprovalDecided, ToolApprovalRequested, ToolCallPrepared, ToolCallResolution, ToolCallResolved, ToolCallSettled, ToolCallUnknown, ToolStepSettled, UserInputRecorded, WorkerAdmission, WorkerInputCompleted, WorkerInputRequested, WorkerOrigin, WorkerOriginRecorded, WorkerReportPrepared, WorkerReportRefused, WorkerReportingIntent };