@minpeter/pss-runtime 0.1.0-next.1 → 0.1.0-next.3

package/dist/execution/host.js

@@ -0,0 +1,62 @@
+//#region src/execution/host.ts
+function sessionHost(host) {
+	const durableHost = durableBackgroundHost(host);
+	if (durableHost?.sessionStore) return durableHost;
+	const hostExecution = executionHost(host);
+	if (hostExecution) return {
+		capabilities: hostExecution.capabilities,
+		sessionStore: hostExecution.store.sessions
+	};
+	return host;
+}
+function executionHost(host) {
+	if (isExecutionHost(host)) return host;
+	if (isDurableBackgroundHost(host)) return executionHostFromDurableBackgroundHost(host);
+}
+function durableBackgroundHost(host) {
+	if (isDurableBackgroundHost(host)) return host;
+	const hostExecution = executionHost(host);
+	if (hostExecution) return durableBackgroundHostFromExecutionHost(hostExecution);
+}
+function isExecutionHost(host) {
+	return "scheduler" in host && "store" in host && isExecutionStore(host.store);
+}
+function isExecutionStore(store) {
+	return typeof store === "object" && store !== null && "checkpoints" in store && "events" in store && "notifications" in store && "runs" in store && "sessions" in store;
+}
+function durableBackgroundHostFromExecutionHost(host) {
+	return {
+		backgroundScheduler: host.scheduler,
+		capabilities: host.capabilities,
+		checkpointStore: host.store.checkpoints,
+		eventStore: host.store.events,
+		notificationInbox: host.store.notifications,
+		runStore: host.store.runs,
+		sessionStore: host.store.sessions,
+		transaction: transactionForStore(host.store)
+	};
+}
+function executionHostFromDurableBackgroundHost(host) {
+	return {
+		capabilities: host.capabilities ?? {},
+		scheduler: host.backgroundScheduler,
+		store: {
+			checkpoints: host.checkpointStore,
+			events: host.eventStore,
+			notifications: host.notificationInbox,
+			runs: host.runStore,
+			sessions: host.sessionStore,
+			transaction: host.transaction
+		}
+	};
+}
+function isDurableBackgroundHost(host) {
+	return "backgroundScheduler" in host && "checkpointStore" in host && "eventStore" in host && "notificationInbox" in host && "runStore" in host && "sessionStore" in host && "transaction" in host;
+}
+function transactionForStore(store) {
+	return (fn) => store.transaction(fn);
+}
+//#endregion
+export { executionHost, sessionHost };
+
+//# sourceMappingURL=host.js.map

package/dist/execution/host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host.js","names":[],"sources":["../../src/execution/host.ts"],"sourcesContent":["import type {\n  DurableBackgroundHost,\n  DurableNotificationResumeHost,\n  SessionHost,\n} from \"./capabilities\";\nimport type { AgentHost, ExecutionHost } from \"./types\";\n\ntype Transaction = ExecutionHost[\"store\"][\"transaction\"];\n\nexport function sessionHost(host: AgentHost): SessionHost {\n  const durableHost = durableBackgroundHost(host);\n  if (durableHost?.sessionStore) {\n    return durableHost;\n  }\n\n  const hostExecution = executionHost(host);\n  if (hostExecution) {\n    return {\n      capabilities: hostExecution.capabilities,\n      sessionStore: hostExecution.store.sessions,\n    };\n  }\n\n  return host;\n}\n\nexport function executionHost(host: AgentHost): ExecutionHost | undefined {\n  if (isExecutionHost(host)) {\n    return host;\n  }\n\n  if (isDurableBackgroundHost(host)) {\n    return executionHostFromDurableBackgroundHost(host);\n  }\n\n  return;\n}\n\nexport function durableBackgroundHost(\n  host: AgentHost\n): DurableBackgroundHost | undefined {\n  if (isDurableBackgroundHost(host)) {\n    return host;\n  }\n\n  const hostExecution = executionHost(host);\n  if (hostExecution) {\n    return durableBackgroundHostFromExecutionHost(hostExecution);\n  }\n\n  return;\n}\n\nexport function durableNotificationResumeHost(\n  host: AgentHost\n): DurableNotificationResumeHost | undefined {\n  const backgroundHost = durableBackgroundHost(host);\n  if (backgroundHost) {\n    return backgroundHost;\n  }\n\n  return;\n}\n\nfunction isExecutionHost(host: AgentHost): host is ExecutionHost {\n  return \"scheduler\" in host && \"store\" in host && isExecutionStore(host.store);\n}\n\nfunction isExecutionStore(store: unknown): store is ExecutionHost[\"store\"] {\n  return (\n    typeof store === \"object\" &&\n    store !== null &&\n    \"checkpoints\" in store &&\n    \"events\" in store &&\n    \"notifications\" in store &&\n    \"runs\" in store &&\n    \"sessions\" in store\n  );\n}\n\nfunction durableBackgroundHostFromExecutionHost(\n  host: ExecutionHost\n): DurableBackgroundHost {\n  return {\n    backgroundScheduler: host.scheduler,\n    capabilities: host.capabilities,\n    checkpointStore: host.store.checkpoints,\n    eventStore: host.store.events,\n    notificationInbox: host.store.notifications,\n    runStore: host.store.runs,\n    sessionStore: host.store.sessions,\n    transaction: transactionForStore(host.store),\n  };\n}\n\nfunction executionHostFromDurableBackgroundHost(\n  host: DurableBackgroundHost\n): ExecutionHost {\n  return {\n    capabilities: host.capabilities ?? {},\n    scheduler: host.backgroundScheduler,\n    store: {\n      checkpoints: host.checkpointStore,\n      events: host.eventStore,\n      notifications: host.notificationInbox,\n      runs: host.runStore,\n      sessions: host.sessionStore,\n      transaction: host.transaction,\n    },\n  };\n}\n\nfunction isDurableBackgroundHost(\n  host: AgentHost\n): host is DurableBackgroundHost {\n  return (\n    \"backgroundScheduler\" in host &&\n    \"checkpointStore\" in host &&\n    \"eventStore\" in host &&\n    \"notificationInbox\" in host &&\n    \"runStore\" in host &&\n    \"sessionStore\" in host &&\n    \"transaction\" in host\n  );\n}\n\nfunction transactionForStore(store: ExecutionHost[\"store\"]): Transaction {\n  return (fn) => store.transaction(fn);\n}\n"],"mappings":";AASA,SAAgB,YAAY,MAA8B;CACxD,MAAM,cAAc,sBAAsB,IAAI;CAC9C,IAAI,aAAa,cACf,OAAO;CAGT,MAAM,gBAAgB,cAAc,IAAI;CACxC,IAAI,eACF,OAAO;EACL,cAAc,cAAc;EAC5B,cAAc,cAAc,MAAM;CACpC;CAGF,OAAO;AACT;AAEA,SAAgB,cAAc,MAA4C;CACxE,IAAI,gBAAgB,IAAI,GACtB,OAAO;CAGT,IAAI,wBAAwB,IAAI,GAC9B,OAAO,uCAAuC,IAAI;AAItD;AAEA,SAAgB,sBACd,MACmC;CACnC,IAAI,wBAAwB,IAAI,GAC9B,OAAO;CAGT,MAAM,gBAAgB,cAAc,IAAI;CACxC,IAAI,eACF,OAAO,uCAAuC,aAAa;AAI/D;AAaA,SAAS,gBAAgB,MAAwC;CAC/D,OAAO,eAAe,QAAQ,WAAW,QAAQ,iBAAiB,KAAK,KAAK;AAC9E;AAEA,SAAS,iBAAiB,OAAiD;CACzE,OACE,OAAO,UAAU,YACjB,UAAU,QACV,iBAAiB,SACjB,YAAY,SACZ,mBAAmB,SACnB,UAAU,SACV,cAAc;AAElB;AAEA,SAAS,uCACP,MACuB;CACvB,OAAO;EACL,qBAAqB,KAAK;EAC1B,cAAc,KAAK;EACnB,iBAAiB,KAAK,MAAM;EAC5B,YAAY,KAAK,MAAM;EACvB,mBAAmB,KAAK,MAAM;EAC9B,UAAU,KAAK,MAAM;EACrB,cAAc,KAAK,MAAM;EACzB,aAAa,oBAAoB,KAAK,KAAK;CAC7C;AACF;AAEA,SAAS,uCACP,MACe;CACf,OAAO;EACL,cAAc,KAAK,gBAAgB,CAAC;EACpC,WAAW,KAAK;EAChB,OAAO;GACL,aAAa,KAAK;GAClB,QAAQ,KAAK;GACb,eAAe,KAAK;GACpB,MAAM,KAAK;GACX,UAAU,KAAK;GACf,aAAa,KAAK;EACpB;CACF;AACF;AAEA,SAAS,wBACP,MAC+B;CAC/B,OACE,yBAAyB,QACzB,qBAAqB,QACrB,gBAAgB,QAChB,uBAAuB,QACvB,cAAc,QACd,kBAAkB,QAClB,iBAAiB;AAErB;AAEA,SAAS,oBAAoB,OAA4C;CACvE,QAAQ,OAAO,MAAM,YAAY,EAAE;AACrC"}

package/dist/execution/index.d.ts

@@ -0,0 +1,6 @@
+import { RuntimeToolExecutionCheckpoint, RuntimeToolExecutionContext, RuntimeToolExecutionDecision, RuntimeToolRetryPolicy, ToolExecutionNeedsRecoveryError } from "../llm-tool-execution.js";
+import { 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 } from "./types.js";
+import { BackgroundScheduler, BackgroundSchedulerHost, CheckpointHost, DurableBackgroundHost, DurableNotificationResumeHost, EventHost, ExecutionTransactionHost, NotificationHost, RunHost, SessionHost } from "./capabilities.js";
+import { executionHost, sessionHost } from "./host.js";
+import { createInMemoryExecutionHost } from "./memory.js";
+export { type AgentHostCapabilities, type BackgroundScheduler, type BackgroundSchedulerHost, type CheckpointHost, type CheckpointPhase, type CheckpointStore, type CheckpointWriteResult, type ClaimRunOptions, type ClaimRunResult, type DurableBackgroundHost, type DurableNotificationResumeHost, type EventCursor, type EventHost, type EventStore, type ExecutionHost, type ExecutionScheduler, type ExecutionStore, type ExecutionStoreTransaction, type ExecutionTransactionHost, type NotificationClaimResult, type NotificationHost, type NotificationInbox, type NotificationRecord, type NotificationStatus, type NotificationWriteResult, type ResumeSessionOptions, type RunCheckpoint, type RunHost, type RunKind, type RunLease, type RunRecord, type RunStatus, type RunStore, type RuntimeToolExecutionCheckpoint, type RuntimeToolExecutionContext, type RuntimeToolExecutionDecision, type RuntimeToolRetryPolicy, type SessionHost, type StoredAgentEvent, ToolExecutionNeedsRecoveryError, createInMemoryExecutionHost, executionHost, sessionHost };

package/dist/execution/index.js

@@ -0,0 +1,4 @@
+import { executionHost, sessionHost } from "./host.js";
+import { createInMemoryExecutionHost } from "./memory.js";
+import { ToolExecutionNeedsRecoveryError } from "../llm-tool-execution.js";
+export { ToolExecutionNeedsRecoveryError, createInMemoryExecutionHost, executionHost, sessionHost };

package/dist/execution/memory-notifications.js

@@ -0,0 +1,54 @@
+//#region src/execution/memory-notifications.ts
+var InMemoryNotificationInbox = class {
+	#state;
+	constructor(state) {
+		this.#state = state;
+	}
+	claimByIdempotencyKey(idempotencyKey) {
+		const record = this.#state().notificationsByKey.get(idempotencyKey);
+		if (!record) return Promise.resolve({
+			ok: false,
+			reason: "not-found"
+		});
+		if (record.status !== "pending") return Promise.resolve({
+			ok: false,
+			reason: "already-claimed",
+			record: structuredClone(record)
+		});
+		this.#state().notificationsByKey.set(idempotencyKey, {
+			...record,
+			status: "acked"
+		});
+		return Promise.resolve({
+			ok: true,
+			record: structuredClone(record)
+		});
+	}
+	enqueue(record) {
+		const existing = this.#state().notificationsByKey.get(record.idempotencyKey);
+		if (existing) return Promise.resolve({
+			existingNotificationId: existing.notificationId,
+			ok: false,
+			reason: "duplicate"
+		});
+		this.#state().notificationsByKey.set(record.idempotencyKey, structuredClone(record));
+		return Promise.resolve({ ok: true });
+	}
+	getByIdempotencyKey(idempotencyKey) {
+		const record = this.#state().notificationsByKey.get(idempotencyKey);
+		return Promise.resolve(record ? structuredClone(record) : null);
+	}
+	releaseByIdempotencyKey(idempotencyKey) {
+		const record = this.#state().notificationsByKey.get(idempotencyKey);
+		if (record?.status !== "acked") return Promise.resolve();
+		this.#state().notificationsByKey.set(idempotencyKey, {
+			...record,
+			status: "pending"
+		});
+		return Promise.resolve();
+	}
+};
+//#endregion
+export { InMemoryNotificationInbox };
+
+//# sourceMappingURL=memory-notifications.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-notifications.js","names":["#state"],"sources":["../../src/execution/memory-notifications.ts"],"sourcesContent":["import type { ExecutionState } from \"./memory-state\";\nimport type {\n  NotificationClaimResult,\n  NotificationInbox,\n  NotificationRecord,\n  NotificationWriteResult,\n} from \"./types\";\n\nexport class InMemoryNotificationInbox implements NotificationInbox {\n  readonly #state: () => ExecutionState;\n\n  constructor(state: () => ExecutionState) {\n    this.#state = state;\n  }\n\n  claimByIdempotencyKey(\n    idempotencyKey: string\n  ): Promise<NotificationClaimResult> {\n    const record = this.#state().notificationsByKey.get(idempotencyKey);\n    if (!record) {\n      return Promise.resolve({ ok: false, reason: \"not-found\" });\n    }\n\n    if (record.status !== \"pending\") {\n      return Promise.resolve({\n        ok: false,\n        reason: \"already-claimed\",\n        record: structuredClone(record),\n      });\n    }\n\n    this.#state().notificationsByKey.set(idempotencyKey, {\n      ...record,\n      status: \"acked\",\n    });\n    return Promise.resolve({\n      ok: true,\n      record: structuredClone(record),\n    });\n  }\n\n  enqueue(record: NotificationRecord): Promise<NotificationWriteResult> {\n    const existing = this.#state().notificationsByKey.get(\n      record.idempotencyKey\n    );\n    if (existing) {\n      return Promise.resolve({\n        existingNotificationId: existing.notificationId,\n        ok: false,\n        reason: \"duplicate\",\n      });\n    }\n\n    this.#state().notificationsByKey.set(\n      record.idempotencyKey,\n      structuredClone(record)\n    );\n    return Promise.resolve({ ok: true });\n  }\n\n  getByIdempotencyKey(\n    idempotencyKey: string\n  ): Promise<NotificationRecord | null> {\n    const record = this.#state().notificationsByKey.get(idempotencyKey);\n    return Promise.resolve(record ? structuredClone(record) : null);\n  }\n\n  releaseByIdempotencyKey(idempotencyKey: string): Promise<void> {\n    const record = this.#state().notificationsByKey.get(idempotencyKey);\n    if (record?.status !== \"acked\") {\n      return Promise.resolve();\n    }\n\n    this.#state().notificationsByKey.set(idempotencyKey, {\n      ...record,\n      status: \"pending\",\n    });\n    return Promise.resolve();\n  }\n}\n"],"mappings":";AAQA,IAAa,4BAAb,MAAoE;CAClE;CAEA,YAAY,OAA6B;EACvC,KAAKA,SAAS;CAChB;CAEA,sBACE,gBACkC;EAClC,MAAM,SAAS,KAAKA,OAAO,EAAE,mBAAmB,IAAI,cAAc;EAClE,IAAI,CAAC,QACH,OAAO,QAAQ,QAAQ;GAAE,IAAI;GAAO,QAAQ;EAAY,CAAC;EAG3D,IAAI,OAAO,WAAW,WACpB,OAAO,QAAQ,QAAQ;GACrB,IAAI;GACJ,QAAQ;GACR,QAAQ,gBAAgB,MAAM;EAChC,CAAC;EAGH,KAAKA,OAAO,EAAE,mBAAmB,IAAI,gBAAgB;GACnD,GAAG;GACH,QAAQ;EACV,CAAC;EACD,OAAO,QAAQ,QAAQ;GACrB,IAAI;GACJ,QAAQ,gBAAgB,MAAM;EAChC,CAAC;CACH;CAEA,QAAQ,QAA8D;EACpE,MAAM,WAAW,KAAKA,OAAO,EAAE,mBAAmB,IAChD,OAAO,cACT;EACA,IAAI,UACF,OAAO,QAAQ,QAAQ;GACrB,wBAAwB,SAAS;GACjC,IAAI;GACJ,QAAQ;EACV,CAAC;EAGH,KAAKA,OAAO,EAAE,mBAAmB,IAC/B,OAAO,gBACP,gBAAgB,MAAM,CACxB;EACA,OAAO,QAAQ,QAAQ,EAAE,IAAI,KAAK,CAAC;CACrC;CAEA,oBACE,gBACoC;EACpC,MAAM,SAAS,KAAKA,OAAO,EAAE,mBAAmB,IAAI,cAAc;EAClE,OAAO,QAAQ,QAAQ,SAAS,gBAAgB,MAAM,IAAI,IAAI;CAChE;CAEA,wBAAwB,gBAAuC;EAC7D,MAAM,SAAS,KAAKA,OAAO,EAAE,mBAAmB,IAAI,cAAc;EAClE,IAAI,QAAQ,WAAW,SACrB,OAAO,QAAQ,QAAQ;EAGzB,KAAKA,OAAO,EAAE,mBAAmB,IAAI,gBAAgB;GACnD,GAAG;GACH,QAAQ;EACV,CAAC;EACD,OAAO,QAAQ,QAAQ;CACzB;AACF"}

package/dist/execution/memory-state.js

@@ -0,0 +1,34 @@
+//#region src/execution/memory-state.ts
+function createEmptyState() {
+	return {
+		checkpoints: /* @__PURE__ */ new Map(),
+		events: /* @__PURE__ */ new Map(),
+		notificationsByKey: /* @__PURE__ */ new Map(),
+		runs: /* @__PURE__ */ new Map(),
+		sessionVersions: /* @__PURE__ */ new Map(),
+		sessions: /* @__PURE__ */ new Map()
+	};
+}
+function cloneState(state) {
+	return {
+		checkpoints: cloneCheckpointMap(state.checkpoints),
+		events: cloneEventMap(state.events),
+		notificationsByKey: cloneRecordMap(state.notificationsByKey),
+		runs: cloneRecordMap(state.runs),
+		sessionVersions: cloneRecordMap(state.sessionVersions),
+		sessions: cloneRecordMap(state.sessions)
+	};
+}
+function cloneCheckpointMap(map) {
+	return new Map([...map.entries()].map(([key, value]) => [key, value.map((checkpoint) => structuredClone(checkpoint))]));
+}
+function cloneEventMap(map) {
+	return new Map([...map.entries()].map(([key, value]) => [key, value.map((event) => structuredClone(event))]));
+}
+function cloneRecordMap(map) {
+	return new Map([...map.entries()].map(([key, value]) => [key, structuredClone(value)]));
+}
+//#endregion
+export { cloneState, createEmptyState };
+
+//# sourceMappingURL=memory-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory-state.js","names":[],"sources":["../../src/execution/memory-state.ts"],"sourcesContent":["import type { StoredSession } from \"../session/store/types\";\nimport type {\n  NotificationRecord,\n  RunCheckpoint,\n  RunRecord,\n  StoredAgentEvent,\n} from \"./types\";\n\nexport interface ExecutionState {\n  readonly checkpoints: Map<string, RunCheckpoint[]>;\n  readonly events: Map<string, StoredAgentEvent[]>;\n  readonly notificationsByKey: Map<string, NotificationRecord>;\n  readonly runs: Map<string, RunRecord>;\n  readonly sessions: Map<string, StoredSession>;\n  readonly sessionVersions: Map<string, number>;\n}\n\nexport function createEmptyState(): ExecutionState {\n  return {\n    checkpoints: new Map(),\n    events: new Map(),\n    notificationsByKey: new Map(),\n    runs: new Map(),\n    sessionVersions: new Map(),\n    sessions: new Map(),\n  };\n}\n\nexport function cloneState(state: ExecutionState): ExecutionState {\n  return {\n    checkpoints: cloneCheckpointMap(state.checkpoints),\n    events: cloneEventMap(state.events),\n    notificationsByKey: cloneRecordMap(state.notificationsByKey),\n    runs: cloneRecordMap(state.runs),\n    sessionVersions: cloneRecordMap(state.sessionVersions),\n    sessions: cloneRecordMap(state.sessions),\n  };\n}\n\nfunction cloneCheckpointMap(\n  map: ReadonlyMap<string, readonly RunCheckpoint[]>\n): Map<string, RunCheckpoint[]> {\n  return new Map(\n    [...map.entries()].map(([key, value]) => [\n      key,\n      value.map((checkpoint) => structuredClone(checkpoint)),\n    ])\n  );\n}\n\nfunction cloneEventMap(\n  map: ReadonlyMap<string, readonly StoredAgentEvent[]>\n): Map<string, StoredAgentEvent[]> {\n  return new Map(\n    [...map.entries()].map(([key, value]) => [\n      key,\n      value.map((event) => structuredClone(event)),\n    ])\n  );\n}\n\nfunction cloneRecordMap<T>(map: ReadonlyMap<string, T>): Map<string, T> {\n  return new Map(\n    [...map.entries()].map(([key, value]) => [key, structuredClone(value)])\n  );\n}\n"],"mappings":";AAiBA,SAAgB,mBAAmC;CACjD,OAAO;EACL,6BAAa,IAAI,IAAI;EACrB,wBAAQ,IAAI,IAAI;EAChB,oCAAoB,IAAI,IAAI;EAC5B,sBAAM,IAAI,IAAI;EACd,iCAAiB,IAAI,IAAI;EACzB,0BAAU,IAAI,IAAI;CACpB;AACF;AAEA,SAAgB,WAAW,OAAuC;CAChE,OAAO;EACL,aAAa,mBAAmB,MAAM,WAAW;EACjD,QAAQ,cAAc,MAAM,MAAM;EAClC,oBAAoB,eAAe,MAAM,kBAAkB;EAC3D,MAAM,eAAe,MAAM,IAAI;EAC/B,iBAAiB,eAAe,MAAM,eAAe;EACrD,UAAU,eAAe,MAAM,QAAQ;CACzC;AACF;AAEA,SAAS,mBACP,KAC8B;CAC9B,OAAO,IAAI,IACT,CAAC,GAAG,IAAI,QAAQ,CAAC,EAAE,KAAK,CAAC,KAAK,WAAW,CACvC,KACA,MAAM,KAAK,eAAe,gBAAgB,UAAU,CAAC,CACvD,CAAC,CACH;AACF;AAEA,SAAS,cACP,KACiC;CACjC,OAAO,IAAI,IACT,CAAC,GAAG,IAAI,QAAQ,CAAC,EAAE,KAAK,CAAC,KAAK,WAAW,CACvC,KACA,MAAM,KAAK,UAAU,gBAAgB,KAAK,CAAC,CAC7C,CAAC,CACH;AACF;AAEA,SAAS,eAAkB,KAA6C;CACtE,OAAO,IAAI,IACT,CAAC,GAAG,IAAI,QAAQ,CAAC,EAAE,KAAK,CAAC,KAAK,WAAW,CAAC,KAAK,gBAAgB,KAAK,CAAC,CAAC,CACxE;AACF"}

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":"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"}

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: {},
+		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    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,CAAC;EACf,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/types.d.ts

@@ -0,0 +1,150 @@
+import { SessionStore } from "../session/store/types.js";
+import { UserInput } from "../session/input.js";
+import { AgentEvent } from "../session/events.js";
+import { DurableBackgroundHost, SessionHost } from "./capabilities.js";
+
+//#region src/execution/types.d.ts
+type AgentHost = DurableBackgroundHost | ExecutionHost | SessionHost;
+interface ExecutionHost {
+  readonly capabilities: AgentHostCapabilities;
+  readonly scheduler: ExecutionScheduler;
+  readonly store: ExecutionStore;
+}
+type AgentHostCapabilities = Record<string, never>;
+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 = "notification" | "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,8 +1,15 @@
-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 { CommitResult, ExpectedSessionVersion, SessionStore, SessionStoreCommit, StoredSession } from "./session/store/types.js";
+import { InputEventMeta, InputSource } from "./session/input-meta-types.js";
 import { AgentInput, SessionInput, UserInput, UserMessage, UserMessageContent, UserMessageContentPart, UserMessageFileData, UserMessageFilePart, UserMessageImagePart, UserMessageTextPart, UserText, UserTextContent } from "./session/input.js";
-import { AgentAfterStepContext, AgentAfterTurnContext, AgentBeforeStepContext, AgentBeforeTurnContext, AgentHooks, AgentStepResult, AgentTurnResult } from "./hooks.js";
-import { AgentEvent, AgentEventListener, AssistantReasoning, AssistantText, RuntimeInput, ToolCall, ToolResult } from "./session/events.js";
+import { AgentEvent, AgentEventListener, AssistantReasoning, AssistantText, ControlAgentEvent, LifecycleAgentEvent, RuntimeInput, TelemetryAgentEvent, ToolAgentEvent, ToolCall, ToolResult, VisibleAgentEvent, isControlAgentEvent, isLifecycleAgentEvent, isTelemetryAgentEvent, isToolAgentEvent, isVisibleAgentEvent } from "./session/events.js";
+import { AgentHost } from "./execution/types.js";
+import { executionHost } from "./execution/host.js";
+import { AgentEventContext, AgentPlugin, AgentPluginInterceptResult, AgentPluginResult, InterceptableAgentEvent, PluginPipelineResult, runPluginsForEvent } from "./plugins.js";
+import { AgentOptions } from "./agent-options.js";
 import { AgentRun } from "./session/run.js";
-import { CommitResult, ExpectedSessionVersion, SessionStore, SessionStoreCommit, StoredSession } from "./session/store/types.js";
-import { Agent, AgentOptions, AgentSessionOptions, SessionHandle } from "./agent.js";
-export { Agent, type AgentAfterStepContext, type AgentAfterTurnContext, type AgentBeforeStepContext, type AgentBeforeTurnContext, type AgentEvent, type AgentEventListener, type AgentHooks, type AgentInput, type AgentOptions, type AgentRun, type AgentSessionOptions, type AgentStepResult, type AgentToolChoice, type AgentToolExecute, type AgentToolExecutionOptions, type AgentTurnResult, type AssistantReasoning, type AssistantText, type CommitResult, type ExpectedSessionVersion, type LlmOutputPart, 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, createLlm };
+import { SessionHandle } from "./agent-session-entry.js";
+import { Agent } from "./agent.js";
+import { delegateUserInput } from "./session/delegate-input.js";
+import { attachInputMeta, attachRuntimeInputMeta, stripEventMeta, stripInputMeta, userInputFromEvent } from "./session/input-meta.js";
+export { Agent, type AgentEvent, type AgentEventContext, type AgentEventListener, type AgentHost, type AgentInput, type AgentOptions, type AgentPlugin, type AgentPluginInterceptResult, type AgentPluginResult, type AgentRun, type AgentToolChoice, type AssistantReasoning, type AssistantText, type CommitResult, type ControlAgentEvent, type ExpectedSessionVersion, type InputEventMeta, type InputSource, type InterceptableAgentEvent, type LifecycleAgentEvent, type PluginPipelineResult, type RuntimeCreateLlmOptions, type RuntimeInput, type RuntimeLlm, type RuntimeLlmContext, type RuntimeLlmOutput, type RuntimeLlmOutputPart, type SessionHandle, type SessionInput, type SessionStore, type SessionStoreCommit, type StoredSession, type TelemetryAgentEvent, type ToolAgentEvent, type ToolCall, type ToolResult, type UserInput, type UserMessage, type UserMessageContent, type UserMessageContentPart, type UserMessageFileData, type UserMessageFilePart, type UserMessageImagePart, type UserMessageTextPart, type UserText, type UserTextContent, type VisibleAgentEvent, attachInputMeta, attachRuntimeInputMeta, createLlm, delegateUserInput, executionHost, isControlAgentEvent, isLifecycleAgentEvent, isTelemetryAgentEvent, isToolAgentEvent, isVisibleAgentEvent, runPluginsForEvent, stripEventMeta, stripInputMeta, userInputFromEvent };