@effect-agent/storage-sqlite 0.1.0-beta.56 → 0.1.0-beta.58

package/dist/SqliteActivityStore.d.mts

@@ -1,6 +1,6 @@
-import { ActivityMutationFailpoint, ActivityMutationFailure, ActivityProcessorStore, ActivityStoreError } from "@effect-agent/thread/ActivityStore";
 import { Layer } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
+import { ActivityMutationFailpoint, ActivityMutationFailure, ActivityProcessorStore, ActivityStoreError } from "@effect-agent/thread/ActivityStore";
 declare namespace SqliteActivityStore_d_exports {
   export { SqliteActivityInitializationError, activityProcessorStoreLayer, activityProcessorStoreLayerWithFailpoints };
 }

package/dist/SqliteActivityStore.mjs

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { ActivityBusy, ActivityClaim, ActivityClaimRequest, ActivityMutationFailpoint, ActivityOwnershipLost, ActivityProcessorKey, ActivityProcessorStore, ActivityProgress, ActivityStoreError, ActivityWorkConflict, PreparedActivity } from "@effect-agent/thread/ActivityStore";
-import { Digest } from "@effect-agent/thread/Records";
 import { Clock, Effect, Layer, Schema } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
+import { Digest } from "@effect-agent/thread/Records";
+import { ActivityBusy, ActivityClaim, ActivityClaimRequest, ActivityMutationFailpoint, ActivityOwnershipLost, ActivityProcessorKey, ActivityProcessorStore, ActivityProgress, ActivityStoreError, ActivityWorkConflict, PreparedActivity } from "@effect-agent/thread/ActivityStore";
 //#region src/SqliteActivityStore.ts
 var SqliteActivityStore_exports = /* @__PURE__ */ __exportAll({
 	activityProcessorStoreLayer: () => activityProcessorStoreLayer,

package/dist/SqliteMessageDeliveryStore.d.mts

@@ -0,0 +1,14 @@
+import { a as SqliteStorageCompatibilityError, o as SqliteStorageCorruptionError, s as SqliteStorageError } from "./SqliteStorageError-CzKmwCLl.mjs";
+import { SqliteStorageConfig } from "./SqliteStorageConfig.mjs";
+import { SqliteStorageFailpoint } from "./SqliteStorageFailpoint.mjs";
+import { MessageDeliveryError, MessageDeliveryStore, MessageDeliveryStoreLimits } from "@effect-agent/thread/MessageDelivery";
+import { Layer } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+declare namespace SqliteMessageDeliveryStore_d_exports {
+  export { messageDeliveryStoreLayer };
+}
+/** Source-owned message obligations in the host's existing SQLite database. */
+declare const messageDeliveryStoreLayer: (limits?: MessageDeliveryStoreLimits) => Layer.Layer<MessageDeliveryStore, MessageDeliveryError | SqliteStorageCompatibilityError | SqliteStorageCorruptionError | SqliteStorageError, SqlClient.SqlClient | SqliteStorageConfig | SqliteStorageFailpoint>;
+//#endregion
+export { messageDeliveryStoreLayer, SqliteMessageDeliveryStore_d_exports as t };
+//# sourceMappingURL=SqliteMessageDeliveryStore.d.mts.map

package/dist/SqliteMessageDeliveryStore.mjs

@@ -0,0 +1,24 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as initializeSqliteJournal } from "./sqlite-journal-lDduEakl.mjs";
+import { MessageDeliveryError, MessageDeliveryStore } from "@effect-agent/thread/MessageDelivery";
+import { SqlMessageDeliveryTransaction, makeSqlMessageDeliveryStore } from "@effect-agent/thread/SqlMessageDeliveryStore";
+import { Effect, Layer } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+//#region src/SqliteMessageDeliveryStore.ts
+var SqliteMessageDeliveryStore_exports = /* @__PURE__ */ __exportAll({ messageDeliveryStoreLayer: () => messageDeliveryStoreLayer });
+const transactions = Layer.effect(SqlMessageDeliveryTransaction, Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	return SqlMessageDeliveryTransaction.of({ run: (body) => sql.withTransaction(body).pipe(Effect.catchTag("SqlError", () => MessageDeliveryError.make({
+		reason: "storage",
+		operation: "transaction"
+	}))) });
+}));
+/** Source-owned message obligations in the host's existing SQLite database. */
+const messageDeliveryStoreLayer = (limits) => Layer.effect(MessageDeliveryStore, Effect.gen(function* () {
+	yield* initializeSqliteJournal();
+	return yield* makeSqlMessageDeliveryStore(limits, { maxStoredValueBytes: 16777216 });
+})).pipe(Layer.provide(transactions));
+//#endregion
+export { messageDeliveryStoreLayer, SqliteMessageDeliveryStore_exports as t };
+
+//# sourceMappingURL=SqliteMessageDeliveryStore.mjs.map

package/dist/SqliteMessageDeliveryStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteMessageDeliveryStore.mjs","names":[],"sources":["../src/SqliteMessageDeliveryStore.ts"],"sourcesContent":["import {\n  MessageDeliveryError,\n  MessageDeliveryStore,\n  type MessageDeliveryStoreLimits,\n} from \"@effect-agent/thread/MessageDelivery\";\nimport {\n  makeSqlMessageDeliveryStore,\n  SqlMessageDeliveryTransaction,\n} from \"@effect-agent/thread/SqlMessageDeliveryStore\";\nimport { Effect, Layer } from \"effect\";\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\";\n\nimport { initializeSqliteJournal } from \"./internal/sqlite-journal.ts\";\n\nconst transactions = Layer.effect(\n  SqlMessageDeliveryTransaction,\n  Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n\n    return SqlMessageDeliveryTransaction.of({\n      run: (body) =>\n        sql\n          .withTransaction(body)\n          .pipe(\n            Effect.catchTag(\"SqlError\", () =>\n              MessageDeliveryError.make({ reason: \"storage\", operation: \"transaction\" }),\n            ),\n          ),\n    });\n  }),\n);\n\n/** Source-owned message obligations in the host's existing SQLite database. */\nexport const messageDeliveryStoreLayer = (limits?: MessageDeliveryStoreLimits) =>\n  Layer.effect(\n    MessageDeliveryStore,\n    Effect.gen(function* () {\n      yield* initializeSqliteJournal();\n\n      return yield* makeSqlMessageDeliveryStore(limits, { maxStoredValueBytes: 16 * 1024 * 1024 });\n    }),\n  ).pipe(Layer.provide(transactions));\n"],"mappings":";;;;;;;;AAcA,MAAM,eAAe,MAAM,OACzB,+BACA,OAAO,IAAI,aAAa;CACtB,MAAM,MAAM,OAAO,UAAU;CAE7B,OAAO,8BAA8B,GAAG,EACtC,MAAM,SACJ,IACG,gBAAgB,IAAI,CAAC,CACrB,KACC,OAAO,SAAS,kBACd,qBAAqB,KAAK;EAAE,QAAQ;EAAW,WAAW;CAAc,CAAC,CAC3E,CACF,EACN,CAAC;AACH,CAAC,CACH;;AAGA,MAAa,6BAA6B,WACxC,MAAM,OACJ,sBACA,OAAO,IAAI,aAAa;CACtB,OAAO,wBAAwB;CAE/B,OAAO,OAAO,4BAA4B,QAAQ,EAAE,qBAAqB,SAAiB,CAAC;AAC7F,CAAC,CACH,CAAC,CAAC,KAAK,MAAM,QAAQ,YAAY,CAAC"}

package/dist/SqliteScheduleStore.mjs

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as initializeSqliteJournal } from "./sqlite-journal-Ce8lwVYx.mjs";
+import { a as initializeSqliteJournal } from "./sqlite-journal-lDduEakl.mjs";
 import { Effect, Layer, Result, Schema } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
 import { ScheduleCapacityError, ScheduleChange, ScheduleConflict, ScheduleDueCursor, ScheduleFailpoint, ScheduleId, ScheduleInstant, ScheduleKey, ScheduleNotFound, ScheduleOwner, SchedulePageRequest, ScheduleRecord, ScheduleStorageError, ScheduleStore, defaultSchedulingLimits } from "@effect-agent/thread/Schedule";

package/dist/SqliteStorageError.mjs

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { CanonicalSequence, ProducerEpoch } from "@effect-agent/thread/Records";
 import { Schema } from "effect";
+import { CanonicalSequence, ProducerEpoch } from "@effect-agent/thread/Records";
 //#region src/SqliteStorageError.ts
 var SqliteStorageError_exports = /* @__PURE__ */ __exportAll({
 	SqliteAppendConflict: () => SqliteAppendConflict,

package/dist/{SqliteStorageVersion-DiIVkDFv.d.mts → SqliteStorageVersion-gA7_96xM.d.mts}

@@ -1,9 +1,9 @@
 import { SqliteMigrator } from "@effect/sql-sqlite-node";
 //#region src/internal/migrations.d.ts
-declare const CurrentSqliteStorageVersion = 8;
+declare const CurrentSqliteStorageVersion = 9;
 declare namespace SqliteStorageVersion_d_exports {
   export { CurrentSqliteStorageVersion };
 }
 //#endregion
 export { CurrentSqliteStorageVersion as n, SqliteStorageVersion_d_exports as t };
-//# sourceMappingURL=SqliteStorageVersion-DiIVkDFv.d.mts.map
+//# sourceMappingURL=SqliteStorageVersion-gA7_96xM.d.mts.map

package/dist/SqliteStorageVersion.d.mts

@@ -1,2 +1,2 @@
-import { n as CurrentSqliteStorageVersion } from "./SqliteStorageVersion-DiIVkDFv.mjs";
+import { n as CurrentSqliteStorageVersion } from "./SqliteStorageVersion-gA7_96xM.mjs";
 export { CurrentSqliteStorageVersion };

package/dist/SqliteStorageVersion.mjs

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { t as CurrentSqliteStorageVersion } from "./migrations-BKcJueHB.mjs";
+import { t as CurrentSqliteStorageVersion } from "./migrations-dnTR0RKq.mjs";
 //#region src/SqliteStorageVersion.ts
-var SqliteStorageVersion_exports = /* @__PURE__ */ __exportAll({ CurrentSqliteStorageVersion: () => 8 });
+var SqliteStorageVersion_exports = /* @__PURE__ */ __exportAll({ CurrentSqliteStorageVersion: () => 9 });
 //#endregion
 export { CurrentSqliteStorageVersion, SqliteStorageVersion_exports as t };
 

package/dist/SqliteSubmissionLedger.mjs

@@ -2,13 +2,14 @@ import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { SqliteStorageConfig } from "./SqliteStorageConfig.mjs";
 import { SqliteLedgerError, SqliteStorageCorruptionError, SqliteStorageError, SqliteWriteContention } from "./SqliteStorageError.mjs";
 import { SqliteStorageFailpoint } from "./SqliteStorageFailpoint.mjs";
-import { a as initializeSqliteJournal, i as decodeRows } from "./sqlite-journal-Ce8lwVYx.mjs";
+import { a as initializeSqliteJournal, i as decodeRows } from "./sqlite-journal-lDduEakl.mjs";
 import { storageConfigLayer, storageFailpointLayer } from "./SqliteThreadStore.mjs";
-import { ApprovalDecision, CanonicalSequence, DefinitionDigests, Digest, PersistedJson, ProducerEpoch, RecordEnvelope, SettlementOutcome } from "@effect-agent/thread/Records";
 import { Clock, Context, Crypto, DateTime, Effect, Layer, Option, Schema, Stream } from "effect";
 import * as SqlClientService from "effect/unstable/sql/SqlClient";
+import { ApprovalDecision, CanonicalSequence, DefinitionDigests, Digest, PersistedJson, ProducerEpoch, RecordEnvelope, SettlementOutcome, WorkerAdmission } from "@effect-agent/thread/Records";
 import { NodeCrypto } from "@effect/platform-node";
 import { SqliteClient } from "@effect/sql-sqlite-node";
+import { MessageAdmission } from "@effect-agent/core/Messaging";
 import { EMPTY_TAIL_DIGEST } from "@effect-agent/thread/Digest";
 import { AbortCommand, AbortIntent, AbortIntentRequest, AdmissionAdmitted, AdmissionConflict, AdmissionFence, AdmissionGroup, AdmissionNotAdmitted, AdmissionPolicyError, AdmissionRequest, AdmissionResult, ApprovalConflict, ApprovalDecisionCommand, ApprovalDecisionIntent, AttachChildToReservationRequest, BeginChildBudgetReleaseRequest, ChildAttachmentSnapshot, ChildBudgetReservationRequest, ChildBudgetReservationSnapshot, ChildReservationConflict, ChildReservationStatus, ChildSettledNotification, Claim, ClaimJoiningRequest, ClaimRequest, InputAppliedMarker, JoinSnapshot, JoinedToHost, JoiningClaim, LedgerCapabilities, LedgerError, MarkInputAppliedRequest, MarkJoinedRequest, MarkReadyRequest, MarkUnknownRequest, OwnershipLost, OwnershipRenewal, OwnershipSnapshot, ParentLinkage, QueueSequence, RecoverySnapshot, RecoverySnapshotRequest, ReleaseChildBudgetRequest, ReleaseOwnershipRequest, RenewOwnershipRequest, ReservedChildBudget, ReservedSettlement, RevertJoiningRequest, Settlement, SettlementConflict, SettlementFinalization, SettlementReservation, SettlementReservationSnapshot, SubmissionAdmissionFence, SubmissionLedger, SubmissionLookup, SubmissionLookupByKey, SubmissionSnapshot, SubmissionState, SuspendRequest, SuspensionReason, SuspensionSnapshot, UnknownResolution, UnknownResolutionCommand, UnknownResolutionConflict, UnknownResolutionIntent, settlementFailureFromRecord, submissionAbortRecordId } from "@effect-agent/thread/SubmissionLedger";
 //#region src/SqliteSubmissionLedger.ts
@@ -52,7 +53,9 @@ var SubmissionRow = class extends Schema.Class("SubmissionRow")({
 	parent_submission_id: Schema.NullOr(BoundedIdentifier),
 	parent_tool_call_id: Schema.NullOr(BoundedIdentifier),
 	admission_group: Schema.NullOr(AdmissionGroup),
-	admission_fence_json: Schema.NullOr(BoundedStoredText)
+	admission_fence_json: Schema.NullOr(BoundedStoredText),
+	worker_admission_json: Schema.NullOr(BoundedStoredText),
+	message_admission_json: Schema.NullOr(BoundedStoredText)
 }) {};
 var ChildReservationRow = class extends Schema.Class("ChildReservationRow")({
 	reservation_id: BoundedIdentifier,
@@ -144,7 +147,9 @@ const SUBMISSION_COLUMNS = `
   parent_submission_id,
   parent_tool_call_id,
   admission_group,
-  admission_fence_json
+  admission_fence_json,
+  worker_admission_json,
+  message_admission_json
 `;
 const CHILD_RESERVATION_COLUMNS = `
   reservation_id,
@@ -313,6 +318,8 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 			state: row.state,
 			createdAt: row.created_at,
 			...row.admission_group === null ? {} : { admissionGroup: row.admission_group },
+			...row.worker_admission_json === null ? {} : { workerAdmission: yield* parseStoredJsonText(row.worker_admission_json).pipe(Effect.mapError(internalFailure(operation))) },
+			...row.message_admission_json === null ? {} : { messageAdmission: yield* parseStoredJsonText(row.message_admission_json).pipe(Effect.mapError(internalFailure(operation))) },
 			...row.admission_fence_json === null ? {} : { admissionFence: yield* parseStoredJsonText(row.admission_fence_json).pipe(Effect.mapError(internalFailure(operation))) },
 			...row.settled_outcome === null ? {} : { settledOutcome: row.settled_outcome },
 			...row.ready_at === null ? {} : { readyAt: row.ready_at },
@@ -481,6 +488,16 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 		const operation = "ledger admit";
 		const validated = yield* Schema.decodeUnknownEffect(Schema.toType(AdmissionRequest))(request).pipe(Effect.mapError(internalFailure(operation)));
 		const inputJson = yield* encodePersistedJsonText(validated.inputPayload).pipe(Effect.mapError(internalFailure(operation)));
+		const workerAdmissionJson = validated.workerAdmission === void 0 ? null : yield* Schema.encodeEffect(Schema.fromJsonString(WorkerAdmission))(validated.workerAdmission).pipe(Effect.mapError(internalFailure(operation)));
+		if (workerAdmissionJson !== null && new TextEncoder().encode(workerAdmissionJson).byteLength > 16777216) return yield* LedgerError.make({
+			operation,
+			message: "Worker admission metadata exceeds the stored value bound"
+		});
+		const messageAdmissionJson = validated.messageAdmission === void 0 ? null : yield* Schema.encodeEffect(Schema.fromJsonString(MessageAdmission))(validated.messageAdmission).pipe(Effect.mapError(internalFailure(operation)));
+		if (messageAdmissionJson !== null && new TextEncoder().encode(messageAdmissionJson).byteLength > 16777216) return yield* LedgerError.make({
+			operation,
+			message: "Message admission metadata exceeds the stored value bound"
+		});
 		const agentDigestsJson = yield* encodeDefinitionDigestsText(validated.agentDigests).pipe(Effect.mapError(internalFailure(operation)));
 		const mintedSubmissionId = yield* mintIdentifier("submission", operation);
 		const mintedReceiptId = yield* mintIdentifier("receipt", operation);
@@ -505,8 +522,10 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 					existingInputDigest: existing[0].input_digest,
 					attemptedInputDigest: validated.inputDigest
 				});
+				const retainedWorkerAdmission = existing[0].worker_admission_json === null ? void 0 : yield* Schema.decodeEffect(Schema.fromJsonString(WorkerAdmission))(existing[0].worker_admission_json).pipe(Effect.mapError(internalFailure(operation)));
+				const retainedMessageAdmission = existing[0].message_admission_json === null ? void 0 : yield* Schema.decodeEffect(Schema.fromJsonString(MessageAdmission))(existing[0].message_admission_json).pipe(Effect.mapError(internalFailure(operation)));
 				const retainedFence = existing[0].admission_fence_json === null ? void 0 : yield* Schema.decodeEffect(Schema.fromJsonString(AdmissionFence))(existing[0].admission_fence_json).pipe(Effect.mapError(internalFailure(operation)));
-				if ((existing[0].admission_group ?? void 0) !== validated.admissionGroup || !Schema.toEquivalence(Schema.optional(AdmissionFence))(retainedFence, validated.admissionFence)) return yield* AdmissionConflict.make({
+				if ((existing[0].admission_group ?? void 0) !== validated.admissionGroup || !Schema.toEquivalence(Schema.optional(WorkerAdmission))(retainedWorkerAdmission, validated.workerAdmission) || !Schema.toEquivalence(Schema.optional(MessageAdmission))(retainedMessageAdmission, validated.messageAdmission) || !Schema.toEquivalence(Schema.optional(AdmissionFence))(retainedFence, validated.admissionFence)) return yield* AdmissionConflict.make({
 					threadId: validated.threadId,
 					principal: validated.principal,
 					idempotencyKey: validated.idempotencyKey,
@@ -521,6 +540,18 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
 					replayed: true
 				}).pipe(Effect.mapError(internalFailure(operation)));
 			}
+			const firstRows = yield* sql`
+            SELECT worker_admission_json FROM effect_agent_submissions
+            WHERE thread_id=${validated.threadId} ORDER BY queue_sequence LIMIT 1
+          `.pipe(Effect.mapError(sqlFailure(operation)));
+			const first = yield* Schema.decodeUnknownEffect(Schema.Array(Schema.Struct({ worker_admission_json: Schema.NullOr(BoundedStoredText) })))(firstRows).pipe(Effect.mapError(internalFailure(operation)));
+			if (first[0] !== void 0) {
+				const previous = first[0].worker_admission_json === null ? void 0 : yield* Schema.decodeEffect(Schema.fromJsonString(WorkerAdmission))(first[0].worker_admission_json).pipe(Effect.mapError(internalFailure(operation)));
+				if (!Schema.toEquivalence(Schema.optional(WorkerAdmission.fields.origin))(previous?.origin, validated.workerAdmission?.origin)) return yield* AdmissionPolicyError.make({
+					reason: "refused",
+					code: "worker-origin-conflict"
+				});
+			}
 			yield* admissionFence.check(validated);
 			if (validated.admissionGroup !== void 0) {
 				if ((yield* sql`
@@ -557,7 +588,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               parent_submission_id,
               parent_tool_call_id,
               admission_group,
-              admission_fence_json
+              admission_fence_json,
+  worker_admission_json,
+  message_admission_json
             ) VALUES (
               ${mintedSubmissionId},
               ${validated.threadId},
@@ -575,7 +608,9 @@ const makeServices = Effect.fn("SqliteSubmissionLedger.makeServices")(function*
               ${validated.parentLinkage?.parentSubmissionId ?? null},
               ${validated.parentLinkage?.parentToolCallId ?? null},
               ${validated.admissionGroup ?? null},
-              ${validated.admissionFence === void 0 ? null : JSON.stringify(validated.admissionFence)}
+              ${validated.admissionFence === void 0 ? null : JSON.stringify(validated.admissionFence)},
+              ${workerAdmissionJson},
+              ${messageAdmissionJson}
             )
           `.pipe(Effect.mapError(sqlFailure(operation)));
 			return yield* decodeAdmissionResult({