@minpeter/pss-runtime 0.1.0-next.0 → 0.1.0-next.2

package/dist/execution/memory-store.js

@@ -0,0 +1,203 @@
+import { InMemoryNotificationInbox } from "./memory-notifications.js";
+import { cloneState, createEmptyState } from "./memory-state.js";
+//#region src/execution/memory-store.ts
+const claimableStatuses = new Set([
+	"leased",
+	"queued",
+	"running",
+	"suspended"
+]);
+var InMemoryExecutionStore = class {
+	#state = createEmptyState();
+	#transactionChain = Promise.resolve();
+	checkpoints = new InMemoryCheckpointStore(() => this.#state);
+	events = new InMemoryEventStore(() => this.#state);
+	notifications = new InMemoryNotificationInbox(() => this.#state);
+	runs = new InMemoryRunStore(() => this.#state);
+	sessions = new InMemoryExecutionSessionStore(() => this.#state);
+	async transaction(fn) {
+		const previousTransaction = this.#transactionChain;
+		let releaseTransaction = () => void 0;
+		this.#transactionChain = new Promise((resolve) => {
+			releaseTransaction = resolve;
+		});
+		await previousTransaction;
+		const transactionState = cloneState(this.#state);
+		const transactionStore = new InMemoryTransactionStore(transactionState);
+		try {
+			const result = await fn(transactionStore);
+			this.#state = transactionState;
+			return result;
+		} finally {
+			releaseTransaction();
+		}
+	}
+};
+var InMemoryTransactionStore = class {
+	checkpoints;
+	events;
+	notifications;
+	runs;
+	sessions;
+	#state;
+	constructor(state) {
+		this.#state = state;
+		this.checkpoints = new InMemoryCheckpointStore(() => this.#state);
+		this.events = new InMemoryEventStore(() => this.#state);
+		this.notifications = new InMemoryNotificationInbox(() => this.#state);
+		this.runs = new InMemoryRunStore(() => this.#state);
+		this.sessions = new InMemoryExecutionSessionStore(() => this.#state);
+	}
+};
+var InMemoryExecutionSessionStore = class {
+	#state;
+	constructor(state) {
+		this.#state = state;
+	}
+	commit(key, next, options) {
+		const state = this.#state();
+		const currentVersion = state.sessions.get(key)?.version ?? null;
+		if (options.expectedVersion !== currentVersion) return Promise.resolve({
+			ok: false,
+			reason: "conflict"
+		});
+		const versionNumber = (state.sessionVersions.get(key) ?? 0) + 1;
+		const version = String(versionNumber);
+		state.sessionVersions.set(key, versionNumber);
+		state.sessions.set(key, structuredClone({
+			state: next.state,
+			version
+		}));
+		return Promise.resolve({
+			ok: true,
+			version
+		});
+	}
+	delete(key) {
+		const state = this.#state();
+		state.sessions.delete(key);
+		state.sessionVersions.delete(key);
+		return Promise.resolve();
+	}
+	load(key) {
+		const stored = this.#state().sessions.get(key);
+		return Promise.resolve(stored ? structuredClone(stored) : null);
+	}
+};
+var InMemoryRunStore = class {
+	#state;
+	constructor(state) {
+		this.#state = state;
+	}
+	create(record) {
+		const stored = structuredClone(record);
+		this.#state().runs.set(record.runId, stored);
+		return Promise.resolve(structuredClone(stored));
+	}
+	get(runId) {
+		const record = this.#state().runs.get(runId);
+		return Promise.resolve(record ? structuredClone(record) : null);
+	}
+	getByDedupeKey(dedupeKey) {
+		const record = [...this.#state().runs.values()].find((candidate) => candidate.dedupeKey === dedupeKey);
+		return Promise.resolve(record ? structuredClone(record) : null);
+	}
+	listByParentRunId(parentRunId) {
+		const records = [...this.#state().runs.values()].filter((candidate) => candidate.parentRunId === parentRunId);
+		return Promise.resolve(records.map((record) => structuredClone(record)));
+	}
+	update(record) {
+		const stored = structuredClone(record);
+		this.#state().runs.set(record.runId, stored);
+		return Promise.resolve(structuredClone(stored));
+	}
+	claim(runId, options) {
+		const record = this.#state().runs.get(runId);
+		if (!record) return Promise.resolve({
+			ok: false,
+			reason: "not-found"
+		});
+		if (!claimableStatuses.has(record.status)) return Promise.resolve({
+			ok: false,
+			reason: "not-claimable"
+		});
+		if (record.lease && record.lease.leaseUntilMs > options.nowMs) return Promise.resolve({
+			ok: false,
+			reason: "leased"
+		});
+		const lease = {
+			attempt: options.attempt,
+			leaseId: options.leaseId,
+			leaseUntilMs: options.nowMs + options.leaseMs
+		};
+		const claimed = {
+			...record,
+			lease,
+			status: "leased"
+		};
+		this.#state().runs.set(runId, claimed);
+		return Promise.resolve({
+			lease,
+			ok: true,
+			record: structuredClone(claimed)
+		});
+	}
+};
+var InMemoryCheckpointStore = class {
+	#state;
+	constructor(state) {
+		this.#state = state;
+	}
+	append(checkpoint, options) {
+		const run = this.#state().runs.get(checkpoint.runId);
+		const currentVersion = run?.checkpointVersion ?? 0;
+		if (currentVersion !== options.expectedVersion) return Promise.resolve({
+			currentVersion,
+			ok: false,
+			reason: "stale-version"
+		});
+		const stored = structuredClone(checkpoint);
+		const checkpoints = this.#state().checkpoints.get(checkpoint.runId) ?? [];
+		checkpoints.push(stored);
+		this.#state().checkpoints.set(checkpoint.runId, checkpoints);
+		if (run) this.#state().runs.set(checkpoint.runId, {
+			...run,
+			checkpointVersion: checkpoint.version
+		});
+		return Promise.resolve({
+			ok: true,
+			version: checkpoint.version
+		});
+	}
+	latest(runId) {
+		const checkpoint = (this.#state().checkpoints.get(runId) ?? []).at(-1);
+		return Promise.resolve(checkpoint ? structuredClone(checkpoint) : null);
+	}
+};
+var InMemoryEventStore = class {
+	#state;
+	constructor(state) {
+		this.#state = state;
+	}
+	append(runId, event) {
+		const events = this.#state().events.get(runId) ?? [];
+		const cursor = { offset: events.length + 1 };
+		events.push({
+			cursor,
+			event: structuredClone(event),
+			runId
+		});
+		this.#state().events.set(runId, events);
+		return Promise.resolve(cursor);
+	}
+	async *read(runId, cursor) {
+		await Promise.resolve();
+		const events = this.#state().events.get(runId) ?? [];
+		const start = cursor?.offset ?? 0;
+		for (const event of events.slice(start)) yield structuredClone(event);
+	}
+};
+//#endregion
+export { InMemoryExecutionStore };
+
+//# sourceMappingURL=memory-store.js.map

package/dist/execution/memory-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.js","names":["#state","#transactionChain"],"sources":["../../src/execution/memory-store.ts"],"sourcesContent":["import type { AgentEvent } from \"../session/events\";\nimport type {\n  CommitResult,\n  ExpectedSessionVersion,\n  SessionStore,\n  SessionStoreCommit,\n  StoredSession,\n} from \"../session/store/types\";\nimport { InMemoryNotificationInbox } from \"./memory-notifications\";\nimport type { ExecutionState } from \"./memory-state\";\nimport { cloneState, createEmptyState } from \"./memory-state\";\nimport type {\n  CheckpointStore,\n  CheckpointWriteResult,\n  ClaimRunOptions,\n  ClaimRunResult,\n  EventCursor,\n  EventStore,\n  ExecutionStore,\n  ExecutionStoreTransaction,\n  NotificationInbox,\n  RunCheckpoint,\n  RunRecord,\n  RunStatus,\n  RunStore,\n  StoredAgentEvent,\n} from \"./types\";\n\nconst claimableStatuses = new Set<RunStatus>([\n  \"leased\",\n  \"queued\",\n  \"running\",\n  \"suspended\",\n]);\n\nexport class InMemoryExecutionStore implements ExecutionStore {\n  #state = createEmptyState();\n  #transactionChain: Promise<void> = Promise.resolve();\n  readonly checkpoints: CheckpointStore = new InMemoryCheckpointStore(\n    () => this.#state\n  );\n  readonly events: EventStore = new InMemoryEventStore(() => this.#state);\n  readonly notifications: NotificationInbox = new InMemoryNotificationInbox(\n    () => this.#state\n  );\n  readonly runs: RunStore = new InMemoryRunStore(() => this.#state);\n  readonly sessions: SessionStore = new InMemoryExecutionSessionStore(\n    () => this.#state\n  );\n\n  async transaction<T>(\n    fn: (tx: ExecutionStoreTransaction) => Promise<T>\n  ): Promise<T> {\n    const previousTransaction = this.#transactionChain;\n    let releaseTransaction: () => void = () => undefined;\n    this.#transactionChain = new Promise<void>((resolve) => {\n      releaseTransaction = resolve;\n    });\n    await previousTransaction;\n    const transactionState = cloneState(this.#state);\n    const transactionStore = new InMemoryTransactionStore(transactionState);\n    try {\n      const result = await fn(transactionStore);\n      this.#state = transactionState;\n      return result;\n    } finally {\n      releaseTransaction();\n    }\n  }\n}\n\nclass InMemoryTransactionStore implements ExecutionStoreTransaction {\n  readonly checkpoints: CheckpointStore;\n  readonly events: EventStore;\n  readonly notifications: NotificationInbox;\n  readonly runs: RunStore;\n  readonly sessions: SessionStore;\n  readonly #state: ExecutionState;\n\n  constructor(state: ExecutionState) {\n    this.#state = state;\n    this.checkpoints = new InMemoryCheckpointStore(() => this.#state);\n    this.events = new InMemoryEventStore(() => this.#state);\n    this.notifications = new InMemoryNotificationInbox(() => this.#state);\n    this.runs = new InMemoryRunStore(() => this.#state);\n    this.sessions = new InMemoryExecutionSessionStore(() => this.#state);\n  }\n}\n\nclass InMemoryExecutionSessionStore implements SessionStore {\n  readonly #state: () => ExecutionState;\n\n  constructor(state: () => ExecutionState) {\n    this.#state = state;\n  }\n\n  commit(\n    key: string,\n    next: SessionStoreCommit,\n    options: { readonly expectedVersion: ExpectedSessionVersion }\n  ): Promise<CommitResult> {\n    const state = this.#state();\n    const current = state.sessions.get(key);\n    const currentVersion = current?.version ?? null;\n\n    if (options.expectedVersion !== currentVersion) {\n      return Promise.resolve({ ok: false, reason: \"conflict\" });\n    }\n\n    const versionNumber = (state.sessionVersions.get(key) ?? 0) + 1;\n    const version = String(versionNumber);\n    state.sessionVersions.set(key, versionNumber);\n    state.sessions.set(key, structuredClone({ state: next.state, version }));\n    return Promise.resolve({ ok: true, version });\n  }\n\n  delete(key: string): Promise<void> {\n    const state = this.#state();\n    state.sessions.delete(key);\n    state.sessionVersions.delete(key);\n    return Promise.resolve();\n  }\n\n  load(key: string): Promise<StoredSession | null> {\n    const stored = this.#state().sessions.get(key);\n    return Promise.resolve(stored ? structuredClone(stored) : null);\n  }\n}\n\nclass InMemoryRunStore implements RunStore {\n  readonly #state: () => ExecutionState;\n\n  constructor(state: () => ExecutionState) {\n    this.#state = state;\n  }\n\n  create(record: RunRecord): Promise<RunRecord> {\n    const stored = structuredClone(record);\n    this.#state().runs.set(record.runId, stored);\n    return Promise.resolve(structuredClone(stored));\n  }\n\n  get(runId: string): Promise<RunRecord | null> {\n    const record = this.#state().runs.get(runId);\n    return Promise.resolve(record ? structuredClone(record) : null);\n  }\n\n  getByDedupeKey(dedupeKey: string): Promise<RunRecord | null> {\n    const record = [...this.#state().runs.values()].find(\n      (candidate) => candidate.dedupeKey === dedupeKey\n    );\n    return Promise.resolve(record ? structuredClone(record) : null);\n  }\n\n  listByParentRunId(parentRunId: string): Promise<readonly RunRecord[]> {\n    const records = [...this.#state().runs.values()].filter(\n      (candidate) => candidate.parentRunId === parentRunId\n    );\n    return Promise.resolve(records.map((record) => structuredClone(record)));\n  }\n\n  update(record: RunRecord): Promise<RunRecord> {\n    const stored = structuredClone(record);\n    this.#state().runs.set(record.runId, stored);\n    return Promise.resolve(structuredClone(stored));\n  }\n\n  claim(runId: string, options: ClaimRunOptions): Promise<ClaimRunResult> {\n    const record = this.#state().runs.get(runId);\n    if (!record) {\n      return Promise.resolve({ ok: false, reason: \"not-found\" });\n    }\n\n    if (!claimableStatuses.has(record.status)) {\n      return Promise.resolve({ ok: false, reason: \"not-claimable\" });\n    }\n\n    if (record.lease && record.lease.leaseUntilMs > options.nowMs) {\n      return Promise.resolve({ ok: false, reason: \"leased\" });\n    }\n\n    const lease = {\n      attempt: options.attempt,\n      leaseId: options.leaseId,\n      leaseUntilMs: options.nowMs + options.leaseMs,\n    };\n    const claimed: RunRecord = {\n      ...record,\n      lease,\n      status: \"leased\",\n    };\n    this.#state().runs.set(runId, claimed);\n    return Promise.resolve({\n      lease,\n      ok: true,\n      record: structuredClone(claimed),\n    });\n  }\n}\n\nclass InMemoryCheckpointStore implements CheckpointStore {\n  readonly #state: () => ExecutionState;\n\n  constructor(state: () => ExecutionState) {\n    this.#state = state;\n  }\n\n  append(\n    checkpoint: RunCheckpoint,\n    options: { readonly expectedVersion: number }\n  ): Promise<CheckpointWriteResult> {\n    const run = this.#state().runs.get(checkpoint.runId);\n    const currentVersion = run?.checkpointVersion ?? 0;\n    if (currentVersion !== options.expectedVersion) {\n      return Promise.resolve({\n        currentVersion,\n        ok: false,\n        reason: \"stale-version\",\n      });\n    }\n\n    const stored = structuredClone(checkpoint);\n    const checkpoints = this.#state().checkpoints.get(checkpoint.runId) ?? [];\n    checkpoints.push(stored);\n    this.#state().checkpoints.set(checkpoint.runId, checkpoints);\n    if (run) {\n      this.#state().runs.set(checkpoint.runId, {\n        ...run,\n        checkpointVersion: checkpoint.version,\n      });\n    }\n\n    return Promise.resolve({ ok: true, version: checkpoint.version });\n  }\n\n  latest(runId: string): Promise<RunCheckpoint | null> {\n    const checkpoints = this.#state().checkpoints.get(runId) ?? [];\n    const checkpoint = checkpoints.at(-1);\n    return Promise.resolve(checkpoint ? structuredClone(checkpoint) : null);\n  }\n}\n\nclass InMemoryEventStore implements EventStore {\n  readonly #state: () => ExecutionState;\n\n  constructor(state: () => ExecutionState) {\n    this.#state = state;\n  }\n\n  append(runId: string, event: AgentEvent): Promise<EventCursor> {\n    const events = this.#state().events.get(runId) ?? [];\n    const cursor = { offset: events.length + 1 };\n    events.push({\n      cursor,\n      event: structuredClone(event),\n      runId,\n    });\n    this.#state().events.set(runId, events);\n    return Promise.resolve(cursor);\n  }\n\n  async *read(\n    runId: string,\n    cursor?: EventCursor\n  ): AsyncIterable<StoredAgentEvent> {\n    await Promise.resolve();\n    const events = this.#state().events.get(runId) ?? [];\n    const start = cursor?.offset ?? 0;\n    for (const event of events.slice(start)) {\n      yield structuredClone(event);\n    }\n  }\n}\n"],"mappings":";;;AA4BA,MAAM,oBAAoB,IAAI,IAAe;CAC3C;CACA;CACA;CACA;AACF,CAAC;AAED,IAAa,yBAAb,MAA8D;CAC5D,SAAS,iBAAiB;CAC1B,oBAAmC,QAAQ,QAAQ;CACnD,cAAwC,IAAI,8BACpC,KAAKA,MACb;CACA,SAA8B,IAAI,yBAAyB,KAAKA,MAAM;CACtE,gBAA4C,IAAI,gCACxC,KAAKA,MACb;CACA,OAA0B,IAAI,uBAAuB,KAAKA,MAAM;CAChE,WAAkC,IAAI,oCAC9B,KAAKA,MACb;CAEA,MAAM,YACJ,IACY;EACZ,MAAM,sBAAsB,KAAKC;EACjC,IAAI,2BAAuC,KAAA;EAC3C,KAAKA,oBAAoB,IAAI,SAAe,YAAY;GACtD,qBAAqB;EACvB,CAAC;EACD,MAAM;EACN,MAAM,mBAAmB,WAAW,KAAKD,MAAM;EAC/C,MAAM,mBAAmB,IAAI,yBAAyB,gBAAgB;EACtE,IAAI;GACF,MAAM,SAAS,MAAM,GAAG,gBAAgB;GACxC,KAAKA,SAAS;GACd,OAAO;EACT,UAAU;GACR,mBAAmB;EACrB;CACF;AACF;AAEA,IAAM,2BAAN,MAAoE;CAClE;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,OAAuB;EACjC,KAAKA,SAAS;EACd,KAAK,cAAc,IAAI,8BAA8B,KAAKA,MAAM;EAChE,KAAK,SAAS,IAAI,yBAAyB,KAAKA,MAAM;EACtD,KAAK,gBAAgB,IAAI,gCAAgC,KAAKA,MAAM;EACpE,KAAK,OAAO,IAAI,uBAAuB,KAAKA,MAAM;EAClD,KAAK,WAAW,IAAI,oCAAoC,KAAKA,MAAM;CACrE;AACF;AAEA,IAAM,gCAAN,MAA4D;CAC1D;CAEA,YAAY,OAA6B;EACvC,KAAKA,SAAS;CAChB;CAEA,OACE,KACA,MACA,SACuB;EACvB,MAAM,QAAQ,KAAKA,OAAO;EAE1B,MAAM,iBADU,MAAM,SAAS,IAAI,GACN,GAAG,WAAW;EAE3C,IAAI,QAAQ,oBAAoB,gBAC9B,OAAO,QAAQ,QAAQ;GAAE,IAAI;GAAO,QAAQ;EAAW,CAAC;EAG1D,MAAM,iBAAiB,MAAM,gBAAgB,IAAI,GAAG,KAAK,KAAK;EAC9D,MAAM,UAAU,OAAO,aAAa;EACpC,MAAM,gBAAgB,IAAI,KAAK,aAAa;EAC5C,MAAM,SAAS,IAAI,KAAK,gBAAgB;GAAE,OAAO,KAAK;GAAO;EAAQ,CAAC,CAAC;EACvE,OAAO,QAAQ,QAAQ;GAAE,IAAI;GAAM;EAAQ,CAAC;CAC9C;CAEA,OAAO,KAA4B;EACjC,MAAM,QAAQ,KAAKA,OAAO;EAC1B,MAAM,SAAS,OAAO,GAAG;EACzB,MAAM,gBAAgB,OAAO,GAAG;EAChC,OAAO,QAAQ,QAAQ;CACzB;CAEA,KAAK,KAA4C;EAC/C,MAAM,SAAS,KAAKA,OAAO,EAAE,SAAS,IAAI,GAAG;EAC7C,OAAO,QAAQ,QAAQ,SAAS,gBAAgB,MAAM,IAAI,IAAI;CAChE;AACF;AAEA,IAAM,mBAAN,MAA2C;CACzC;CAEA,YAAY,OAA6B;EACvC,KAAKA,SAAS;CAChB;CAEA,OAAO,QAAuC;EAC5C,MAAM,SAAS,gBAAgB,MAAM;EACrC,KAAKA,OAAO,EAAE,KAAK,IAAI,OAAO,OAAO,MAAM;EAC3C,OAAO,QAAQ,QAAQ,gBAAgB,MAAM,CAAC;CAChD;CAEA,IAAI,OAA0C;EAC5C,MAAM,SAAS,KAAKA,OAAO,EAAE,KAAK,IAAI,KAAK;EAC3C,OAAO,QAAQ,QAAQ,SAAS,gBAAgB,MAAM,IAAI,IAAI;CAChE;CAEA,eAAe,WAA8C;EAC3D,MAAM,SAAS,CAAC,GAAG,KAAKA,OAAO,EAAE,KAAK,OAAO,CAAC,EAAE,MAC7C,cAAc,UAAU,cAAc,SACzC;EACA,OAAO,QAAQ,QAAQ,SAAS,gBAAgB,MAAM,IAAI,IAAI;CAChE;CAEA,kBAAkB,aAAoD;EACpE,MAAM,UAAU,CAAC,GAAG,KAAKA,OAAO,EAAE,KAAK,OAAO,CAAC,EAAE,QAC9C,cAAc,UAAU,gBAAgB,WAC3C;EACA,OAAO,QAAQ,QAAQ,QAAQ,KAAK,WAAW,gBAAgB,MAAM,CAAC,CAAC;CACzE;CAEA,OAAO,QAAuC;EAC5C,MAAM,SAAS,gBAAgB,MAAM;EACrC,KAAKA,OAAO,EAAE,KAAK,IAAI,OAAO,OAAO,MAAM;EAC3C,OAAO,QAAQ,QAAQ,gBAAgB,MAAM,CAAC;CAChD;CAEA,MAAM,OAAe,SAAmD;EACtE,MAAM,SAAS,KAAKA,OAAO,EAAE,KAAK,IAAI,KAAK;EAC3C,IAAI,CAAC,QACH,OAAO,QAAQ,QAAQ;GAAE,IAAI;GAAO,QAAQ;EAAY,CAAC;EAG3D,IAAI,CAAC,kBAAkB,IAAI,OAAO,MAAM,GACtC,OAAO,QAAQ,QAAQ;GAAE,IAAI;GAAO,QAAQ;EAAgB,CAAC;EAG/D,IAAI,OAAO,SAAS,OAAO,MAAM,eAAe,QAAQ,OACtD,OAAO,QAAQ,QAAQ;GAAE,IAAI;GAAO,QAAQ;EAAS,CAAC;EAGxD,MAAM,QAAQ;GACZ,SAAS,QAAQ;GACjB,SAAS,QAAQ;GACjB,cAAc,QAAQ,QAAQ,QAAQ;EACxC;EACA,MAAM,UAAqB;GACzB,GAAG;GACH;GACA,QAAQ;EACV;EACA,KAAKA,OAAO,EAAE,KAAK,IAAI,OAAO,OAAO;EACrC,OAAO,QAAQ,QAAQ;GACrB;GACA,IAAI;GACJ,QAAQ,gBAAgB,OAAO;EACjC,CAAC;CACH;AACF;AAEA,IAAM,0BAAN,MAAyD;CACvD;CAEA,YAAY,OAA6B;EACvC,KAAKA,SAAS;CAChB;CAEA,OACE,YACA,SACgC;EAChC,MAAM,MAAM,KAAKA,OAAO,EAAE,KAAK,IAAI,WAAW,KAAK;EACnD,MAAM,iBAAiB,KAAK,qBAAqB;EACjD,IAAI,mBAAmB,QAAQ,iBAC7B,OAAO,QAAQ,QAAQ;GACrB;GACA,IAAI;GACJ,QAAQ;EACV,CAAC;EAGH,MAAM,SAAS,gBAAgB,UAAU;EACzC,MAAM,cAAc,KAAKA,OAAO,EAAE,YAAY,IAAI,WAAW,KAAK,KAAK,CAAC;EACxE,YAAY,KAAK,MAAM;EACvB,KAAKA,OAAO,EAAE,YAAY,IAAI,WAAW,OAAO,WAAW;EAC3D,IAAI,KACF,KAAKA,OAAO,EAAE,KAAK,IAAI,WAAW,OAAO;GACvC,GAAG;GACH,mBAAmB,WAAW;EAChC,CAAC;EAGH,OAAO,QAAQ,QAAQ;GAAE,IAAI;GAAM,SAAS,WAAW;EAAQ,CAAC;CAClE;CAEA,OAAO,OAA8C;EAEnD,MAAM,cADc,KAAKA,OAAO,EAAE,YAAY,IAAI,KAAK,KAAK,CAAC,GAC9B,GAAG,EAAE;EACpC,OAAO,QAAQ,QAAQ,aAAa,gBAAgB,UAAU,IAAI,IAAI;CACxE;AACF;AAEA,IAAM,qBAAN,MAA+C;CAC7C;CAEA,YAAY,OAA6B;EACvC,KAAKA,SAAS;CAChB;CAEA,OAAO,OAAe,OAAyC;EAC7D,MAAM,SAAS,KAAKA,OAAO,EAAE,OAAO,IAAI,KAAK,KAAK,CAAC;EACnD,MAAM,SAAS,EAAE,QAAQ,OAAO,SAAS,EAAE;EAC3C,OAAO,KAAK;GACV;GACA,OAAO,gBAAgB,KAAK;GAC5B;EACF,CAAC;EACD,KAAKA,OAAO,EAAE,OAAO,IAAI,OAAO,MAAM;EACtC,OAAO,QAAQ,QAAQ,MAAM;CAC/B;CAEA,OAAO,KACL,OACA,QACiC;EACjC,MAAM,QAAQ,QAAQ;EACtB,MAAM,SAAS,KAAKA,OAAO,EAAE,OAAO,IAAI,KAAK,KAAK,CAAC;EACnD,MAAM,QAAQ,QAAQ,UAAU;EAChC,KAAK,MAAM,SAAS,OAAO,MAAM,KAAK,GACpC,MAAM,gBAAgB,KAAK;CAE/B;AACF"}

package/dist/execution/memory.d.ts

@@ -0,0 +1,7 @@
+import { ExecutionHost } from "./types.js";
+
+//#region src/execution/memory.d.ts
+declare function createInMemoryExecutionHost(): ExecutionHost;
+//#endregion
+export { createInMemoryExecutionHost };
+//# sourceMappingURL=memory.d.ts.map

package/dist/execution/memory.js

@@ -0,0 +1,28 @@
+import { InMemoryExecutionStore } from "./memory-store.js";
+//#region src/execution/memory.ts
+function createInMemoryExecutionHost() {
+	return {
+		capabilities: { backgroundSubagents: "in-process" },
+		store: new InMemoryExecutionStore(),
+		scheduler: new InMemoryExecutionScheduler()
+	};
+}
+var InMemoryExecutionScheduler = class {
+	#queuedRunIds = [];
+	#resumedSessions = [];
+	enqueueRun(runId) {
+		this.#queuedRunIds.push(runId);
+		return Promise.resolve();
+	}
+	resumeSession(sessionKey, options) {
+		this.#resumedSessions.push({
+			options,
+			sessionKey
+		});
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { createInMemoryExecutionHost };
+
+//# sourceMappingURL=memory.js.map

package/dist/execution/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","names":["#queuedRunIds","#resumedSessions"],"sources":["../../src/execution/memory.ts"],"sourcesContent":["import { InMemoryExecutionStore } from \"./memory-store\";\nimport type {\n  ExecutionHost,\n  ExecutionScheduler,\n  ResumeSessionOptions,\n} from \"./types\";\n\nexport function createInMemoryExecutionHost(): ExecutionHost {\n  return {\n    capabilities: {\n      backgroundSubagents: \"in-process\",\n    },\n    store: new InMemoryExecutionStore(),\n    scheduler: new InMemoryExecutionScheduler(),\n  };\n}\n\nclass InMemoryExecutionScheduler implements ExecutionScheduler {\n  readonly #queuedRunIds: string[] = [];\n  readonly #resumedSessions: {\n    readonly options: ResumeSessionOptions;\n    readonly sessionKey: string;\n  }[] = [];\n\n  enqueueRun(runId: string): Promise<void> {\n    this.#queuedRunIds.push(runId);\n    return Promise.resolve();\n  }\n\n  resumeSession(\n    sessionKey: string,\n    options: ResumeSessionOptions\n  ): Promise<void> {\n    this.#resumedSessions.push({ options, sessionKey });\n    return Promise.resolve();\n  }\n}\n"],"mappings":";;AAOA,SAAgB,8BAA6C;CAC3D,OAAO;EACL,cAAc,EACZ,qBAAqB,aACvB;EACA,OAAO,IAAI,uBAAuB;EAClC,WAAW,IAAI,2BAA2B;CAC5C;AACF;AAEA,IAAM,6BAAN,MAA+D;CAC7D,gBAAmC,CAAC;CACpC,mBAGM,CAAC;CAEP,WAAW,OAA8B;EACvC,KAAKA,cAAc,KAAK,KAAK;EAC7B,OAAO,QAAQ,QAAQ;CACzB;CAEA,cACE,YACA,SACe;EACf,KAAKC,iBAAiB,KAAK;GAAE;GAAS;EAAW,CAAC;EAClD,OAAO,QAAQ,QAAQ;CACzB;AACF"}

package/dist/execution/run.js

@@ -0,0 +1,55 @@
+//#region src/execution/run.ts
+var StoredAgentRun = class {
+	#cursor;
+	#eventStore;
+	#runId;
+	#eventsStarted = false;
+	constructor({ cursor, eventStore, runId }) {
+		this.#cursor = cursor;
+		this.#eventStore = eventStore;
+		this.#runId = runId;
+	}
+	events() {
+		if (this.#eventsStarted) throw new Error("AgentRun.events() can only be consumed once");
+		this.#eventsStarted = true;
+		return new StoredAgentEventIterator(this.#eventStore.read(this.#runId, this.#cursor));
+	}
+};
+var StoredAgentEventIterator = class {
+	#source;
+	#nextPending = false;
+	constructor(events) {
+		this.#source = events[Symbol.asyncIterator]();
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	async next() {
+		if (this.#nextPending) throw new Error("AgentRun.events() does not allow concurrent next() calls");
+		this.#nextPending = true;
+		try {
+			const next = await this.#source.next();
+			if (next.done) return {
+				done: true,
+				value: void 0
+			};
+			return {
+				done: false,
+				value: next.value.event
+			};
+		} finally {
+			this.#nextPending = false;
+		}
+	}
+	async return() {
+		await this.#source.return?.();
+		return {
+			done: true,
+			value: void 0
+		};
+	}
+};
+//#endregion
+export { StoredAgentRun };
+
+//# sourceMappingURL=run.js.map

package/dist/execution/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","names":["#cursor","#eventStore","#runId","#eventsStarted","#source","#nextPending"],"sources":["../../src/execution/run.ts"],"sourcesContent":["import type { AgentEvent } from \"../session/events\";\nimport type { AgentRun } from \"../session/run\";\nimport type { EventCursor, EventStore, StoredAgentEvent } from \"./types\";\n\nexport class StoredAgentRun implements AgentRun {\n  readonly #cursor: EventCursor | undefined;\n  readonly #eventStore: EventStore;\n  readonly #runId: string;\n  #eventsStarted = false;\n\n  constructor({\n    cursor,\n    eventStore,\n    runId,\n  }: {\n    readonly cursor?: EventCursor;\n    readonly eventStore: EventStore;\n    readonly runId: string;\n  }) {\n    this.#cursor = cursor;\n    this.#eventStore = eventStore;\n    this.#runId = runId;\n  }\n\n  events(): AsyncIterable<AgentEvent> {\n    if (this.#eventsStarted) {\n      throw new Error(\"AgentRun.events() can only be consumed once\");\n    }\n    this.#eventsStarted = true;\n\n    return new StoredAgentEventIterator(\n      this.#eventStore.read(this.#runId, this.#cursor)\n    );\n  }\n}\n\nclass StoredAgentEventIterator implements AsyncIterableIterator<AgentEvent> {\n  readonly #source: AsyncIterator<StoredAgentEvent>;\n  #nextPending = false;\n\n  constructor(events: AsyncIterable<StoredAgentEvent>) {\n    this.#source = events[Symbol.asyncIterator]();\n  }\n\n  [Symbol.asyncIterator](): AsyncIterableIterator<AgentEvent> {\n    return this;\n  }\n\n  async next(): Promise<IteratorResult<AgentEvent>> {\n    if (this.#nextPending) {\n      throw new Error(\n        \"AgentRun.events() does not allow concurrent next() calls\"\n      );\n    }\n\n    this.#nextPending = true;\n    try {\n      const next = await this.#source.next();\n      if (next.done) {\n        return { done: true, value: undefined };\n      }\n\n      return { done: false, value: next.value.event };\n    } finally {\n      this.#nextPending = false;\n    }\n  }\n\n  async return(): Promise<IteratorResult<AgentEvent>> {\n    await this.#source.return?.();\n    return { done: true, value: undefined };\n  }\n}\n"],"mappings":";AAIA,IAAa,iBAAb,MAAgD;CAC9C;CACA;CACA;CACA,iBAAiB;CAEjB,YAAY,EACV,QACA,YACA,SAKC;EACD,KAAKA,UAAU;EACf,KAAKC,cAAc;EACnB,KAAKC,SAAS;CAChB;CAEA,SAAoC;EAClC,IAAI,KAAKC,gBACP,MAAM,IAAI,MAAM,6CAA6C;EAE/D,KAAKA,iBAAiB;EAEtB,OAAO,IAAI,yBACT,KAAKF,YAAY,KAAK,KAAKC,QAAQ,KAAKF,OAAO,CACjD;CACF;AACF;AAEA,IAAM,2BAAN,MAA4E;CAC1E;CACA,eAAe;CAEf,YAAY,QAAyC;EACnD,KAAKI,UAAU,OAAO,OAAO,eAAe;CAC9C;CAEA,CAAC,OAAO,iBAAoD;EAC1D,OAAO;CACT;CAEA,MAAM,OAA4C;EAChD,IAAI,KAAKC,cACP,MAAM,IAAI,MACR,0DACF;EAGF,KAAKA,eAAe;EACpB,IAAI;GACF,MAAM,OAAO,MAAM,KAAKD,QAAQ,KAAK;GACrC,IAAI,KAAK,MACP,OAAO;IAAE,MAAM;IAAM,OAAO,KAAA;GAAU;GAGxC,OAAO;IAAE,MAAM;IAAO,OAAO,KAAK,MAAM;GAAM;EAChD,UAAU;GACR,KAAKC,eAAe;EACtB;CACF;CAEA,MAAM,SAA8C;EAClD,MAAM,KAAKD,QAAQ,SAAS;EAC5B,OAAO;GAAE,MAAM;GAAM,OAAO,KAAA;EAAU;CACxC;AACF"}

package/dist/execution/types.d.ts

@@ -0,0 +1,155 @@
+import { UserInput } from "../session/input.js";
+import { AgentEvent } from "../session/events.js";
+import { SessionStore } from "../session/store/types.js";
+
+//#region src/execution/types.d.ts
+type AgentHost = SessionHost | ExecutionHost;
+interface SessionHost {
+  readonly capabilities?: AgentHostCapabilities;
+  readonly sessionStore?: SessionStore;
+}
+interface ExecutionHost {
+  readonly capabilities: AgentHostCapabilities;
+  readonly scheduler: ExecutionScheduler;
+  readonly store: ExecutionStore;
+}
+interface AgentHostCapabilities {
+  readonly backgroundSubagents?: "durable" | "in-process";
+}
+interface ExecutionScheduler {
+  enqueueRun(runId: string, options?: {
+    readonly runAfterMs?: number;
+  }): Promise<void>;
+  resumeSession(sessionKey: string, options: ResumeSessionOptions): Promise<void>;
+}
+interface ResumeSessionOptions {
+  readonly idempotencyKey?: string;
+  readonly notificationId?: string;
+  readonly runId: string;
+}
+type RunKind = "background-subagent" | "notification" | "subagent" | "tool-recovery" | "user-turn";
+type RunStatus = "cancelled" | "completed" | "error" | "leased" | "needs-recovery" | "queued" | "running" | "suspended";
+interface RunLease {
+  readonly attempt: number;
+  readonly leaseId: string;
+  readonly leaseUntilMs: number;
+}
+interface RunRecord {
+  readonly checkpointVersion: number;
+  readonly dedupeKey?: string;
+  readonly kind: RunKind;
+  readonly lease?: RunLease;
+  readonly output?: unknown;
+  readonly ownerNamespace?: string;
+  readonly parentRunId?: string;
+  readonly publicTaskId?: string;
+  readonly rootRunId: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly status: RunStatus;
+}
+type ClaimRunResult = {
+  readonly lease: RunLease;
+  readonly ok: true;
+  readonly record: RunRecord;
+} | {
+  readonly ok: false;
+  readonly reason: "leased" | "not-claimable" | "not-found";
+};
+interface ClaimRunOptions {
+  readonly attempt: number;
+  readonly leaseId: string;
+  readonly leaseMs: number;
+  readonly nowMs: number;
+}
+type CheckpointPhase = "after-model" | "after-notification" | "after-tool" | "before-child-run" | "before-model" | "before-notification" | "before-tool" | "child-linked" | "suspended";
+interface RunCheckpoint {
+  readonly checkpointId: string;
+  readonly childRunId?: string;
+  readonly pendingToolCall?: unknown;
+  readonly phase: CheckpointPhase;
+  readonly runId: string;
+  readonly runtimeState: unknown;
+  readonly sessionSnapshot: unknown;
+  readonly version: number;
+}
+type CheckpointWriteResult = {
+  readonly ok: true;
+  readonly version: number;
+} | {
+  readonly currentVersion: number;
+  readonly ok: false;
+  readonly reason: "stale-version";
+};
+interface EventCursor {
+  readonly offset: number;
+}
+interface StoredAgentEvent {
+  readonly cursor: EventCursor;
+  readonly event: AgentEvent;
+  readonly runId: string;
+}
+type NotificationStatus = "acked" | "cancelled" | "pending";
+interface NotificationRecord {
+  readonly idempotencyKey: string;
+  readonly input: UserInput;
+  readonly notificationId: string;
+  readonly observerEvents?: readonly AgentEvent[];
+  readonly ownerNamespace?: string;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly status: NotificationStatus;
+}
+type NotificationWriteResult = {
+  readonly ok: true;
+} | {
+  readonly existingNotificationId: string;
+  readonly ok: false;
+  readonly reason: "duplicate";
+};
+type NotificationClaimResult = {
+  readonly ok: true;
+  readonly record: NotificationRecord;
+} | {
+  readonly ok: false;
+  readonly reason: "already-claimed" | "not-found";
+  readonly record?: NotificationRecord;
+};
+interface RunStore {
+  claim(runId: string, options: ClaimRunOptions): Promise<ClaimRunResult>;
+  create(record: RunRecord): Promise<RunRecord>;
+  get(runId: string): Promise<RunRecord | null>;
+  getByDedupeKey(dedupeKey: string): Promise<RunRecord | null>;
+  listByParentRunId(parentRunId: string): Promise<readonly RunRecord[]>;
+  update(record: RunRecord): Promise<RunRecord>;
+}
+interface CheckpointStore {
+  append(checkpoint: RunCheckpoint, options: {
+    readonly expectedVersion: number;
+  }): Promise<CheckpointWriteResult>;
+  latest(runId: string): Promise<RunCheckpoint | null>;
+}
+interface EventStore {
+  append(runId: string, event: AgentEvent): Promise<EventCursor>;
+  read(runId: string, cursor?: EventCursor): AsyncIterable<StoredAgentEvent>;
+}
+interface NotificationInbox {
+  claimByIdempotencyKey(idempotencyKey: string): Promise<NotificationClaimResult>;
+  enqueue(record: NotificationRecord): Promise<NotificationWriteResult>;
+  getByIdempotencyKey(idempotencyKey: string): Promise<NotificationRecord | null>;
+  releaseByIdempotencyKey(idempotencyKey: string): Promise<void>;
+}
+interface ExecutionStorePorts {
+  readonly checkpoints: CheckpointStore;
+  readonly events: EventStore;
+  readonly notifications: NotificationInbox;
+  readonly runs: RunStore;
+  readonly sessions: SessionStore;
+}
+interface ExecutionStoreTransaction extends ExecutionStorePorts {}
+interface ExecutionStore extends ExecutionStorePorts {
+  transaction<T>(fn: (tx: ExecutionStoreTransaction) => Promise<T>): Promise<T>;
+}
+//#endregion
+export { AgentHost, AgentHostCapabilities, CheckpointPhase, CheckpointStore, CheckpointWriteResult, ClaimRunOptions, ClaimRunResult, EventCursor, EventStore, ExecutionHost, ExecutionScheduler, ExecutionStore, ExecutionStoreTransaction, NotificationClaimResult, NotificationInbox, NotificationRecord, NotificationStatus, NotificationWriteResult, ResumeSessionOptions, RunCheckpoint, RunKind, RunLease, RunRecord, RunStatus, RunStore, StoredAgentEvent };
+//# sourceMappingURL=types.d.ts.map

package/dist/index.d.ts

@@ -1,12 +1,11 @@
-import { AgentToolChoice, AgentToolExecute, AgentToolExecutionOptions, LlmOutputPart, RuntimeCreateLlmOptions, RuntimeLlm, RuntimeLlmContext, RuntimeLlmOutput, createLlm } from "./llm.js";
+import { AgentToolChoice, RuntimeCreateLlmOptions, RuntimeLlm, RuntimeLlmContext, RuntimeLlmOutput, RuntimeLlmOutputPart, createLlm } from "./llm.js";
 import { AgentInput, SessionInput, UserInput, UserMessage, UserMessageContent, UserMessageContentPart, UserMessageFileData, UserMessageFilePart, UserMessageImagePart, UserMessageTextPart, UserText, UserTextContent } from "./session/input.js";
-import { AgentEvent, AgentEventListener, AssistantReasoning, AssistantText, OverlayAccepted, OverlayExpired, OverlayInputSummary, OverlayPlacement, RuntimeInput, ToolCall, ToolResult } from "./session/events.js";
-import { AgentRun } from "./session/run.js";
+import { AgentEvent, AgentEventListener, AssistantReasoning, AssistantText, RuntimeInput, ToolCall, ToolResult } from "./session/events.js";
 import { CommitResult, ExpectedSessionVersion, SessionStore, SessionStoreCommit, StoredSession } from "./session/store/types.js";
-import { AgentContextTransform, AgentPlugin, AgentPluginEvent, AgentPluginEventFor, AgentPluginEventName, AgentPluginHandler, AgentPluginHandlerResult, AgentPluginHandlerReturn, AgentPluginHost, AgentPluginMaybePromise, AgentPluginStepAfterEvent, AgentPluginStepBeforeEvent, AgentPluginStepResult, AgentPluginToolCallEvent, AgentPluginToolCallResult, AgentPluginToolResultEvent, AgentPluginToolResultResult, AgentPluginToolResultStatus, AgentPluginToolSyntheticResult, AgentPluginTurnAfterEvent, AgentPluginTurnBeforeEvent, AgentPluginTurnResult, definePlugin } from "./plugins/types.js";
-import { CompactionOptions, compaction } from "./plugins/compaction.js";
-import { memory } from "./plugins/memory.js";
-import { sessions } from "./plugins/sessions.js";
-import { AgentPluginErrorHandler, AgentPluginHandlerError } from "./session/lifecycle.js";
-import { Agent, AgentOptions, SessionHandle } from "./agent.js";
-export { Agent, type AgentContextTransform, type AgentEvent, type AgentEventListener, type AgentInput, type AgentOptions, type AgentPlugin, type AgentPluginErrorHandler, type AgentPluginEvent, type AgentPluginEventFor, type AgentPluginEventName, type AgentPluginHandler, type AgentPluginHandlerError, type AgentPluginHandlerResult, type AgentPluginHandlerReturn, type AgentPluginHost, type AgentPluginMaybePromise, type AgentPluginStepAfterEvent, type AgentPluginStepBeforeEvent, type AgentPluginStepResult, type AgentPluginToolCallEvent, type AgentPluginToolCallResult, type AgentPluginToolResultEvent, type AgentPluginToolResultResult, type AgentPluginToolResultStatus, type AgentPluginToolSyntheticResult, type AgentPluginTurnAfterEvent, type AgentPluginTurnBeforeEvent, type AgentPluginTurnResult, type AgentRun, type AgentToolChoice, type AgentToolExecute, type AgentToolExecutionOptions, type AssistantReasoning, type AssistantText, type CommitResult, type CompactionOptions, type ExpectedSessionVersion, type LlmOutputPart, type OverlayAccepted, type OverlayExpired, type OverlayInputSummary, type OverlayPlacement, type RuntimeCreateLlmOptions, type RuntimeInput, type RuntimeLlm, type RuntimeLlmContext, type RuntimeLlmOutput, type SessionHandle, type SessionInput, type SessionStore, type SessionStoreCommit, type StoredSession, type ToolCall, type ToolResult, type UserInput, type UserMessage, type UserMessageContent, type UserMessageContentPart, type UserMessageFileData, type UserMessageFilePart, type UserMessageImagePart, type UserMessageTextPart, type UserText, type UserTextContent, compaction, createLlm, definePlugin, memory, sessions };
+import { AgentHost } from "./execution/types.js";
+import { AgentEventContext, AgentPlugin } from "./plugins.js";
+import { AgentOptions } from "./agent-options.js";
+import { AgentRun } from "./session/run.js";
+import { SessionHandle } from "./agent-session-entry.js";
+import { Agent } from "./agent.js";
+export { Agent, type AgentEvent, type AgentEventContext, type AgentEventListener, type AgentHost, type AgentInput, type AgentOptions, type AgentPlugin, type AgentRun, type AgentToolChoice, type AssistantReasoning, type AssistantText, type CommitResult, type ExpectedSessionVersion, type RuntimeCreateLlmOptions, type RuntimeInput, type RuntimeLlm, type RuntimeLlmContext, type RuntimeLlmOutput, type RuntimeLlmOutputPart, type SessionHandle, type SessionInput, type SessionStore, type SessionStoreCommit, type StoredSession, type ToolCall, type ToolResult, type UserInput, type UserMessage, type UserMessageContent, type UserMessageContentPart, type UserMessageFileData, type UserMessageFilePart, type UserMessageImagePart, type UserMessageTextPart, type UserText, type UserTextContent, createLlm };

package/dist/index.js

@@ -1,8 +1,3 @@
 import { createLlm } from "./llm.js";
-import { definePlugin } from "./plugins/types.js";
 import { Agent } from "./agent.js";
-import { compaction } from "./plugins/compaction.js";
-import { memory } from "./plugins/memory.js";
-import { sessions } from "./plugins/sessions.js";
-import "./plugins/index.js";
-export { Agent, compaction, createLlm, definePlugin, memory, sessions };
+export { Agent, createLlm };

package/dist/llm-tool-execution.d.ts

@@ -0,0 +1,35 @@
+import { ToolSet } from "ai";
+
+//#region src/llm-tool-execution.d.ts
+type RuntimeToolRetryPolicy = "idempotent" | "manual-recovery" | "pure";
+interface RuntimeToolExecutionCheckpointMetadata {
+  readonly attempt: number;
+  readonly idempotencyKey: string;
+  readonly policy: RuntimeToolRetryPolicy;
+  readonly toolCallId: string;
+  readonly toolName: string;
+}
+interface RuntimeToolExecutionCheckpoint extends RuntimeToolExecutionCheckpointMetadata {
+  readonly input: unknown;
+}
+type RuntimeToolExecutionDecision = {
+  readonly status: "needs-recovery";
+} | undefined;
+interface RuntimeToolExecutionContext {
+  readonly afterTool?: (checkpoint: RuntimeToolExecutionCheckpoint & {
+    readonly output: unknown;
+  }) => Promise<void> | void;
+  readonly attempt: number;
+  readonly beforeTool?: (checkpoint: RuntimeToolExecutionCheckpoint) => Promise<RuntimeToolExecutionDecision> | RuntimeToolExecutionDecision;
+  readonly runId: string;
+}
+declare class ToolExecutionNeedsRecoveryError extends Error {
+  readonly idempotencyKey: string;
+  readonly status = "needs-recovery";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  constructor(checkpoint: RuntimeToolExecutionCheckpointMetadata);
+}
+//#endregion
+export { RuntimeToolExecutionCheckpoint, RuntimeToolExecutionCheckpointMetadata, RuntimeToolExecutionContext, RuntimeToolExecutionDecision, RuntimeToolRetryPolicy, ToolExecutionNeedsRecoveryError };
+//# sourceMappingURL=llm-tool-execution.d.ts.map