@statelyai/agent 2.0.0-alpha.18 → 2.0.0-alpha.19

package/dist/{event-log-store-yquOV1TX.cjs → event-log-store-a_TKy1gk.cjs}

@@ -111,7 +111,7 @@ async function assertEventLogStoreConformance(create) {
 			caught = error;
 		}
 		if (!(caught instanceof AgentEventLogConflictError)) fail("a stale expectedIndex must throw AgentEventLogConflictError");
-		if (caught.threadId !== "t" || caught.expectedIndex !== 0 || caught.actualLength !== 1) fail("conflict error must carry threadId, expectedIndex, and the actual length");
+		if (caught.threadId !== "t" || caught.expectedIndex !== 0 || caught.actualIndex !== 1) fail("conflict error must carry threadId, expectedIndex, and the actual index");
 	}
 	{
 		const store = await create();
@@ -240,10 +240,10 @@ async function assertEventLogStoreConformance(create) {
 		assertJsonEqual((await store.read("fork-1")).map((e) => e.index), [0], "fork with upToIndex 1 must copy only entry 0");
 		await store.fork({
 			threadId: "src",
-			newThreadId: "fork-id",
-			atEventId: "evt_1"
+			newThreadId: "fork-2",
+			upToIndex: 2
 		});
-		assertJsonEqual((await store.read("fork-id")).map((e) => e.id), ["evt_0", "evt_1"], "fork with atEventId must include the named entry");
+		assertJsonEqual((await store.read("fork-2")).map((e) => e.id), ["evt_0", "evt_1"], "fork with upToIndex 2 must copy entries 0 and 1 only");
 		await store.append({
 			threadId: "fork-1",
 			expectedIndex: 1,
@@ -271,6 +271,17 @@ async function assertEventLogStoreConformance(create) {
 			caughtUnknown = error;
 		}
 		if (!(caughtUnknown instanceof Error) || caughtUnknown instanceof AgentEventLogConflictError) fail("forking an unknown source thread must reject with a plain Error");
+		let caughtRange;
+		try {
+			await store.fork({
+				threadId: "src",
+				newThreadId: "fork-range",
+				upToIndex: 99
+			});
+		} catch (error) {
+			caughtRange = error;
+		}
+		if (!(caughtRange instanceof Error) || caughtRange instanceof AgentEventLogConflictError) fail("forking past the source length must reject with a plain Error");
 	}
 }
 //#endregion
@@ -352,18 +363,18 @@ function assertAgentLogEntry(entry) {
 /**
 * Rejection from {@link AgentEventLogStore.append} when the thread's stored
 * length is not the `expectedIndex` the writer held — a concurrent writer
-* appended first. `actualLength` is the length core found.
+* appended first. `actualIndex` is the next index the store would accept.
 */
 var AgentEventLogConflictError = class extends require_errors.AgentError {
 	threadId;
 	expectedIndex;
-	actualLength;
-	constructor(threadId, expectedIndex, actualLength) {
-		super("event-log-conflict", `AgentEventLogStore.append: length conflict on thread "${threadId}": expected length ${expectedIndex} but found ${actualLength} — a concurrent writer won.`);
+	actualIndex;
+	constructor(threadId, expectedIndex, actualIndex) {
+		super("event-log-conflict", `AgentEventLogStore.append: index conflict on thread "${threadId}": expected index ${expectedIndex} but found ${actualIndex} — a concurrent writer won.`);
 		this.name = "AgentEventLogConflictError";
 		this.threadId = threadId;
 		this.expectedIndex = expectedIndex;
-		this.actualLength = actualLength;
+		this.actualIndex = actualIndex;
 	}
 };
 /**
@@ -402,14 +413,11 @@ function createInMemoryEventLogStore() {
 		async length(threadId) {
 			return threads.get(threadId)?.length ?? 0;
 		},
-		async fork({ threadId, newThreadId, upToIndex, atEventId }) {
+		async fork({ threadId, newThreadId, upToIndex }) {
 			if ((threads.get(newThreadId)?.length ?? 0) > 0) throw new Error(`AgentEventLogStore.fork: newThreadId "${newThreadId}" already has entries.`);
 			const source = threads.get(threadId);
 			if (!source) throw new Error(`AgentEventLogStore.fork: unknown source thread "${threadId}".`);
-			if (upToIndex !== void 0 && atEventId !== void 0) throw new Error("AgentEventLogStore.fork: pass either upToIndex or atEventId, not both.");
-			const eventIndex = atEventId === void 0 ? void 0 : source.findIndex((entry) => entry.id === atEventId);
-			if (atEventId !== void 0 && eventIndex === -1) throw new Error(`AgentEventLogStore.fork: thread "${threadId}" has no event id "${atEventId}".`);
-			const upTo = eventIndex === void 0 ? upToIndex ?? source.length : eventIndex + 1;
+			const upTo = upToIndex ?? source.length;
 			if (upTo < 0 || upTo > source.length) throw new Error(`AgentEventLogStore.fork: thread "${threadId}" (length ${source.length}) has no index ${upTo} to fork up to.`);
 			threads.set(newThreadId, source.slice(0, upTo).map((entry) => clone(entry)));
 		}

package/dist/{event-log-store-BrC9Q1xW.d.mts → event-log-store-hrA1vqtN.d.mts}

@@ -107,30 +107,29 @@ interface AgentEventLogStore {
   /** The thread's current log length (0 for an unknown thread) — the next `expectedIndex`. */
   length(threadId: string): Promise<number>;
   /**
-   * Copy a prefix onto a fresh, empty `newThreadId` — either `[0, upToIndex)`
-   * or through the inclusive `atEventId`. With neither cutoff the full source
-   * is copied. The fork then appends independently. Rejects (plain `Error`) if
-   * `newThreadId` already has entries, the source/id is unknown, or both cutoff
-   * forms are supplied. Implementations may copy-on-write or physically copy;
-   * observable behavior must match a full copy.
+   * Copy the prefix `[0, upToIndex)` onto a fresh, empty `newThreadId`.
+   * Without `upToIndex` the full source is copied. The fork then appends
+   * independently. Rejects (plain `Error`) if `newThreadId` already has
+   * entries, the source is unknown, or `upToIndex` is out of range.
+   * Implementations may copy-on-write or physically copy; observable behavior
+   * must match a full copy.
    */
   fork(input: {
     threadId: string;
-    newThreadId: string;
-    upToIndex?: number; /** Inclusive event-id cutoff. Mutually exclusive with `upToIndex`. */
-    atEventId?: string;
+    newThreadId: string; /** Exclusive index cutoff. */
+    upToIndex?: number;
   }): Promise<void>;
 }
 /**
  * Rejection from {@link AgentEventLogStore.append} when the thread's stored
  * length is not the `expectedIndex` the writer held — a concurrent writer
- * appended first. `actualLength` is the length core found.
+ * appended first. `actualIndex` is the next index the store would accept.
  */
 declare class AgentEventLogConflictError extends AgentError {
   readonly threadId: string;
   readonly expectedIndex: number;
-  readonly actualLength: number;
-  constructor(threadId: string, expectedIndex: number, actualLength: number);
+  readonly actualIndex: number;
+  constructor(threadId: string, expectedIndex: number, actualIndex: number);
 }
 /**
  * In-memory reference store, and the baseline the conformance suite runs