@otakumesi/heph 0.0.1

package/dist/sqlite.mjs

@@ -0,0 +1,1140 @@
+import { P as HephError, _ as createMessageId, b as createSkillBindingId, d as createApprovalRequestId, f as createDeferredToolOperationId, g as createMemoryId, h as createMcpBindingId, m as createInboxEventId, u as createAgentSessionId, v as createRunEventId, y as createRunId } from "./src-DeheByi4.mjs";
+import { createRequire } from "node:module";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+//#region ../sqlite/src/index.ts
+const BetterSqlite3 = createRequire(import.meta.url)("better-sqlite3");
+const INITIAL_MIGRATION_VERSION = "0001_initial_heph_sqlite";
+const DEFAULT_MIGRATION_OUTPUT_DIR = "migrations/heph";
+function createSQLiteAdapters(options) {
+	return {
+		stores: createSQLiteHephStore(options),
+		queue: createSQLiteQueue({
+			...options,
+			migrations: {
+				...options.migrations,
+				mode: "none"
+			}
+		})
+	};
+}
+function createSQLiteHephStore(options) {
+	return new SQLiteHephStore(openDatabase(options));
+}
+function createSQLiteQueue(options) {
+	return new SQLiteQueue(openDatabase(options), options);
+}
+function writeSQLiteMigration(outputDir = DEFAULT_MIGRATION_OUTPUT_DIR) {
+	mkdirSync(outputDir, { recursive: true });
+	const file = join(outputDir, `${INITIAL_MIGRATION_VERSION}.sql`);
+	writeFileSync(file, INITIAL_MIGRATION_SQL, "utf8");
+	return file;
+}
+var SQLiteHephStore = class {
+	db;
+	state = this;
+	messages = this;
+	inbox = this;
+	events = this;
+	memory = this;
+	mcpBindings = this;
+	skillBindings = this;
+	approvals = this;
+	deferredToolOperations = this;
+	constructor(db) {
+		this.db = db;
+	}
+	close() {
+		this.db.close();
+	}
+	async createAgentSession(input) {
+		const now = /* @__PURE__ */ new Date();
+		const agent = {
+			id: input.id ?? createAgentSessionId(),
+			agentSpecId: input.agentSpecId,
+			agentSpecVersion: input.agentSpecVersion ?? null,
+			state: input.state ?? {},
+			activeRunId: null,
+			auth: input.auth ?? null,
+			metadata: input.metadata ?? {},
+			createdAt: now,
+			updatedAt: now
+		};
+		this.db.prepare(`insert into heph_agent_sessions
+          (id, agent_spec_id, agent_spec_version, state_json, active_run_id, auth_json, metadata_json, created_at, updated_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(agent.id, agent.agentSpecId, agent.agentSpecVersion, stringifyJson(agent.state), agent.activeRunId, stringifyJson(agent.auth), stringifyJson(agent.metadata), toIso(agent.createdAt), toIso(agent.updatedAt));
+		return clonePlain(agent);
+	}
+	async getAgentSession(id) {
+		const row = this.db.prepare("select * from heph_agent_sessions where id = ?").get(id);
+		return row ? rowToAgentSession(row) : null;
+	}
+	async updateAgentSession(id, patch) {
+		const existing = await this.getAgentSession(id);
+		if (!existing) throw notFound("AgentSession not found", { agentId: id });
+		const updated = {
+			...existing,
+			...patch,
+			id,
+			createdAt: existing.createdAt,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		this.db.prepare(`update heph_agent_sessions
+         set agent_spec_id = ?, agent_spec_version = ?, state_json = ?, active_run_id = ?, auth_json = ?, metadata_json = ?, updated_at = ?
+         where id = ?`).run(updated.agentSpecId, updated.agentSpecVersion, stringifyJson(updated.state), updated.activeRunId, stringifyJson(updated.auth), stringifyJson(updated.metadata), toIso(updated.updatedAt), id);
+		return clonePlain(updated);
+	}
+	async createRun(input) {
+		const now = /* @__PURE__ */ new Date();
+		const run = {
+			id: input.id ?? createRunId(),
+			agentId: input.agentId,
+			agentSpecId: input.agentSpecId,
+			agentSpecVersion: input.agentSpecVersion ?? null,
+			status: input.status,
+			input: input.input,
+			auth: input.auth ?? null,
+			contextManifest: null,
+			skillManifest: null,
+			toolManifest: null,
+			error: null,
+			metadata: input.metadata ?? {},
+			queuedAt: now,
+			startedAt: null,
+			completedAt: null,
+			createdAt: now,
+			updatedAt: now
+		};
+		this.db.prepare(`insert into heph_runs
+          (id, agent_id, agent_spec_id, agent_spec_version, status, input_json, auth_json, context_manifest_json,
+           skill_manifest_json, tool_manifest_json, error_json, metadata_json, queued_at, started_at, completed_at, created_at, updated_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(run.id, run.agentId, run.agentSpecId, run.agentSpecVersion, run.status, stringifyJson(run.input), stringifyJson(run.auth), stringifyJson(run.contextManifest), stringifyJson(run.skillManifest), stringifyJson(run.toolManifest), stringifyJson(run.error), stringifyJson(run.metadata), toIso(run.queuedAt), toIsoOrNull(run.startedAt), toIsoOrNull(run.completedAt), toIso(run.createdAt), toIso(run.updatedAt));
+		return clonePlain(run);
+	}
+	async getRun(id) {
+		const row = this.db.prepare("select * from heph_runs where id = ?").get(id);
+		return row ? rowToRun(row) : null;
+	}
+	async updateRun(id, patch) {
+		const existing = await this.getRun(id);
+		if (!existing) throw notFound("Run not found", { runId: id });
+		const updated = {
+			...existing,
+			...patch,
+			id,
+			createdAt: existing.createdAt,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		this.db.prepare(`update heph_runs
+         set agent_id = ?, agent_spec_id = ?, agent_spec_version = ?, status = ?, input_json = ?, auth_json = ?,
+             context_manifest_json = ?, skill_manifest_json = ?, tool_manifest_json = ?, error_json = ?, metadata_json = ?, queued_at = ?, started_at = ?,
+             completed_at = ?, updated_at = ?
+         where id = ?`).run(updated.agentId, updated.agentSpecId, updated.agentSpecVersion, updated.status, stringifyJson(updated.input), stringifyJson(updated.auth), stringifyJson(updated.contextManifest), stringifyJson(updated.skillManifest), stringifyJson(updated.toolManifest), stringifyJson(updated.error), stringifyJson(updated.metadata), toIso(updated.queuedAt), toIsoOrNull(updated.startedAt), toIsoOrNull(updated.completedAt), toIso(updated.updatedAt), id);
+		return clonePlain(updated);
+	}
+	async listRunsByAgent(agentId) {
+		return this.db.prepare("select * from heph_runs where agent_id = ? order by created_at asc, id asc").all(agentId).map((row) => rowToRun(row));
+	}
+	async appendMessage(input) {
+		const message = {
+			id: input.id ?? createMessageId(),
+			agentId: input.agentId,
+			role: input.role,
+			content: input.content,
+			sourceRunId: input.sourceRunId ?? null,
+			auth: input.auth ?? null,
+			metadata: input.metadata ?? {},
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		this.db.prepare(`insert into heph_messages
+          (id, agent_id, role, content, source_run_id, auth_json, metadata_json, created_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?)`).run(message.id, message.agentId, message.role, message.content, message.sourceRunId, stringifyJson(message.auth), stringifyJson(message.metadata), toIso(message.createdAt));
+		return clonePlain(message);
+	}
+	async listMessages(agentId, options = {}) {
+		const params = [agentId];
+		let sql = "select * from heph_messages where agent_id = ? order by created_at desc, id desc";
+		if (options.limit !== void 0) {
+			sql += " limit ?";
+			params.push(options.limit);
+		}
+		return this.db.prepare(sql).all(...params).map((row) => rowToMessage(row)).reverse();
+	}
+	async appendInboxEvent(input) {
+		const now = /* @__PURE__ */ new Date();
+		const event = {
+			id: input.id ?? createInboxEventId(),
+			agentId: input.agentId,
+			type: input.input.type,
+			input: input.input,
+			status: "pending",
+			runId: null,
+			auth: input.auth ?? null,
+			metadata: input.metadata ?? {},
+			createdAt: now,
+			updatedAt: now,
+			claimedAt: null,
+			processedAt: null,
+			failedAt: null,
+			error: null
+		};
+		this.db.prepare(`insert into heph_inbox_events
+          (id, agent_id, type, input_json, status, run_id, auth_json, metadata_json, created_at, updated_at,
+           claimed_at, claim_lease_until, processed_at, failed_at, error_json, attempt)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(event.id, event.agentId, event.type, stringifyJson(event.input), event.status, event.runId, stringifyJson(event.auth), stringifyJson(event.metadata), toIso(event.createdAt), toIso(event.updatedAt), toIsoOrNull(event.claimedAt), null, toIsoOrNull(event.processedAt), toIsoOrNull(event.failedAt), stringifyJson(event.error), 0);
+		return clonePlain(event);
+	}
+	async getInboxEvent(id) {
+		const row = this.db.prepare("select * from heph_inbox_events where id = ?").get(id);
+		return row ? rowToInboxEvent(row) : null;
+	}
+	async listInboxEvents(agentId, options = {}) {
+		const where = ["agent_id = ?"];
+		const params = [agentId];
+		if (options.status !== void 0) {
+			where.push("status = ?");
+			params.push(options.status);
+		}
+		if (options.types !== void 0 && options.types.length > 0) {
+			where.push(`type in (${options.types.map(() => "?").join(", ")})`);
+			params.push(...options.types);
+		}
+		let sql = `select * from heph_inbox_events where ${where.join(" and ")} order by created_at asc, id asc`;
+		if (options.limit !== void 0) {
+			sql += " limit ?";
+			params.push(options.limit);
+		}
+		return this.db.prepare(sql).all(...params).map((row) => rowToInboxEvent(row));
+	}
+	async claimPendingInboxEvents(agentId, options = {}) {
+		return this.db.transaction(() => {
+			const now = /* @__PURE__ */ new Date();
+			const leaseUntil = new Date(now.getTime() + 3e4);
+			const where = ["agent_id = ?", "(status = 'pending' or (status = 'processing' and claim_lease_until <= ?))"];
+			const params = [agentId, toIso(now)];
+			if (options.types !== void 0 && options.types.length > 0) {
+				where.push(`type in (${options.types.map(() => "?").join(", ")})`);
+				params.push(...options.types);
+			}
+			let sql = `select * from heph_inbox_events where ${where.join(" and ")} order by created_at asc, id asc`;
+			if (options.limit !== void 0) {
+				sql += " limit ?";
+				params.push(options.limit);
+			}
+			const rows = this.db.prepare(sql).all(...params);
+			const update = this.db.prepare(`update heph_inbox_events
+         set status = 'processing', claimed_at = ?, claim_lease_until = ?, updated_at = ?, attempt = attempt + 1
+         where id = ?`);
+			for (const row of rows) update.run(toIso(now), toIso(leaseUntil), toIso(now), row.id);
+			return rows.map((row) => ({
+				...row,
+				status: "processing",
+				claimed_at: toIso(now),
+				claim_lease_until: toIso(leaseUntil),
+				updated_at: toIso(now),
+				attempt: row.attempt + 1
+			}));
+		})().map(rowToInboxEvent);
+	}
+	async markInboxEventsProcessed(ids, runId) {
+		return this.db.transaction(() => {
+			const now = /* @__PURE__ */ new Date();
+			const update = this.db.prepare(`update heph_inbox_events
+         set status = 'processed', run_id = ?, processed_at = ?, updated_at = ?, error_json = null
+         where id = ?`);
+			for (const id of ids) update.run(runId, toIso(now), toIso(now), id);
+			return ids.map((id) => {
+				const row = this.db.prepare("select * from heph_inbox_events where id = ?").get(id);
+				if (!row) throw notFound("InboxEvent not found", { inboxEventId: id });
+				return row;
+			});
+		})().map(rowToInboxEvent);
+	}
+	async markInboxEventsFailed(ids, error) {
+		return this.db.transaction(() => {
+			const now = /* @__PURE__ */ new Date();
+			const update = this.db.prepare(`update heph_inbox_events
+         set status = 'failed', failed_at = ?, updated_at = ?, error_json = ?
+         where id = ?`);
+			for (const id of ids) update.run(toIso(now), toIso(now), stringifyJson(error), id);
+			return ids.map((id) => {
+				const row = this.db.prepare("select * from heph_inbox_events where id = ?").get(id);
+				if (!row) throw notFound("InboxEvent not found", { inboxEventId: id });
+				return row;
+			});
+		})().map(rowToInboxEvent);
+	}
+	async appendRunEvent(input) {
+		return clonePlain(this.db.transaction(() => {
+			const seqRow = this.db.prepare("select coalesce(max(seq), 0) + 1 as seq from heph_run_events where run_id = ?").get(input.runId);
+			const event = {
+				id: input.id ?? createRunEventId(),
+				runId: input.runId,
+				seq: seqRow.seq,
+				type: input.type,
+				payload: input.payload ?? {},
+				sourceRefs: input.sourceRefs ?? [],
+				createdAt: /* @__PURE__ */ new Date()
+			};
+			this.db.prepare(`insert into heph_run_events
+            (id, run_id, seq, type, payload_json, source_refs_json, created_at)
+           values (?, ?, ?, ?, ?, ?, ?)`).run(event.id, event.runId, event.seq, event.type, stringifyJson(event.payload), stringifyJson(event.sourceRefs), toIso(event.createdAt));
+			return event;
+		})());
+	}
+	async listRunEvents(runId, options = {}) {
+		const params = [runId, options.after ?? 0];
+		let sql = "select * from heph_run_events where run_id = ? and seq > ? order by seq asc";
+		if (options.limit !== void 0) {
+			sql += " limit ?";
+			params.push(options.limit);
+		}
+		return this.db.prepare(sql).all(...params).map((row) => rowToRunEvent(row));
+	}
+	async putMemory(input) {
+		const now = /* @__PURE__ */ new Date();
+		const existing = input.id ? this.db.prepare("select * from heph_memory_items where id = ?").get(input.id) ?? null : null;
+		const item = {
+			id: input.id ?? createMemoryId(),
+			scope: input.scope,
+			kind: input.kind,
+			content: input.content,
+			sourceRefs: input.sourceRefs,
+			importance: input.importance ?? null,
+			confidence: input.confidence ?? null,
+			embeddingRef: input.embeddingRef ?? null,
+			expiresAt: input.expiresAt ?? null,
+			createdAt: existing ? parseDate(existing.created_at) : now,
+			updatedAt: now
+		};
+		this.db.prepare(`insert into heph_memory_items
+          (id, scope_type, scope_id, kind, content, source_refs_json, importance, confidence, embedding_ref, expires_at, created_at, updated_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         on conflict(id) do update set
+           scope_type = excluded.scope_type,
+           scope_id = excluded.scope_id,
+           kind = excluded.kind,
+           content = excluded.content,
+           source_refs_json = excluded.source_refs_json,
+           importance = excluded.importance,
+           confidence = excluded.confidence,
+           embedding_ref = excluded.embedding_ref,
+           expires_at = excluded.expires_at,
+           updated_at = excluded.updated_at`).run(item.id, item.scope.type, item.scope.id, item.kind, item.content, stringifyJson(item.sourceRefs), item.importance, item.confidence, item.embeddingRef, toIsoOrNull(item.expiresAt), toIso(item.createdAt), toIso(item.updatedAt));
+		return clonePlain(item);
+	}
+	async searchMemory(input) {
+		const rows = this.db.prepare("select * from heph_memory_items").all();
+		const now = Date.now();
+		const query = input.query?.trim().toLowerCase();
+		const topK = input.topK ?? 8;
+		const scopes = input.scopes ?? [];
+		return rows.map(rowToMemoryItem).filter((item) => item.expiresAt === null || item.expiresAt.getTime() > now).filter((item) => scopes.length === 0 || scopes.some((scope) => sameScope(scope, item.scope))).map((item) => ({
+			item,
+			score: scoreMemory(item, query)
+		})).filter(({ score }) => score > 0 || !query).sort((a, b) => b.score - a.score || b.item.updatedAt.getTime() - a.item.updatedAt.getTime()).slice(0, topK).map(({ item }) => clonePlain(item));
+	}
+	async createMcpBinding(input) {
+		const now = /* @__PURE__ */ new Date();
+		const binding = {
+			id: input.id ?? createMcpBindingId(),
+			agentId: input.agentId,
+			capabilityId: input.capabilityId,
+			accountRef: input.accountRef ?? null,
+			allowTools: clonePlain(input.allowTools),
+			status: "active",
+			metadata: input.metadata ?? {},
+			createdAt: now,
+			updatedAt: now,
+			removedAt: null
+		};
+		this.db.prepare(`insert into heph_mcp_bindings
+          (id, agent_id, capability_id, account_ref, allow_tools_json, status, metadata_json, created_at, updated_at, removed_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(binding.id, binding.agentId, binding.capabilityId, binding.accountRef, stringifyJson(binding.allowTools), binding.status, stringifyJson(binding.metadata), toIso(binding.createdAt), toIso(binding.updatedAt), toIsoOrNull(binding.removedAt));
+		return clonePlain(binding);
+	}
+	async getMcpBinding(id) {
+		const row = this.db.prepare("select * from heph_mcp_bindings where id = ?").get(id);
+		return row ? rowToMcpBinding(row) : null;
+	}
+	async listMcpBindings(agentId, options = {}) {
+		const params = [agentId];
+		let sql = "select * from heph_mcp_bindings where agent_id = ?";
+		const status = options.status ?? "active";
+		if (status !== "all") {
+			sql += " and status = ?";
+			params.push(status);
+		}
+		sql += " order by created_at asc, id asc";
+		return this.db.prepare(sql).all(...params).map((row) => rowToMcpBinding(row));
+	}
+	async removeMcpBinding(id) {
+		const existing = await this.getMcpBinding(id);
+		if (!existing) throw notFound("McpBinding not found", { bindingId: id });
+		const now = /* @__PURE__ */ new Date();
+		const removedAt = existing.removedAt ?? now;
+		this.db.prepare("update heph_mcp_bindings set status = 'removed', updated_at = ?, removed_at = ? where id = ?").run(toIso(now), toIso(removedAt), id);
+		return {
+			...existing,
+			status: "removed",
+			updatedAt: now,
+			removedAt
+		};
+	}
+	async createSkillBinding(input) {
+		const now = /* @__PURE__ */ new Date();
+		const binding = {
+			id: input.id ?? createSkillBindingId(),
+			agentId: input.agentId,
+			skillId: input.skillId,
+			name: input.name,
+			version: input.version ?? null,
+			source: clonePlain(input.source),
+			allowReferences: input.allowReferences === void 0 ? [] : clonePlain(input.allowReferences),
+			status: "active",
+			metadata: input.metadata ?? {},
+			createdAt: now,
+			updatedAt: now,
+			removedAt: null
+		};
+		this.db.prepare(`insert into heph_skill_bindings
+          (id, agent_id, skill_id, name, version, source_json, allow_references_json, status,
+           metadata_json, created_at, updated_at, removed_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(binding.id, binding.agentId, binding.skillId, binding.name, binding.version, stringifyJson(binding.source), stringifyJson(binding.allowReferences), binding.status, stringifyJson(binding.metadata), toIso(binding.createdAt), toIso(binding.updatedAt), toIsoOrNull(binding.removedAt));
+		return clonePlain(binding);
+	}
+	async getSkillBinding(id) {
+		const row = this.db.prepare("select * from heph_skill_bindings where id = ?").get(id);
+		return row ? rowToSkillBinding(row) : null;
+	}
+	async listSkillBindings(agentId, options = {}) {
+		const params = [agentId];
+		let sql = "select * from heph_skill_bindings where agent_id = ?";
+		const status = options.status ?? "active";
+		if (status !== "all") {
+			sql += " and status = ?";
+			params.push(status);
+		}
+		sql += " order by created_at asc, id asc";
+		return this.db.prepare(sql).all(...params).map((row) => rowToSkillBinding(row));
+	}
+	async removeSkillBinding(id) {
+		const existing = await this.getSkillBinding(id);
+		if (!existing) throw notFound("SkillBinding not found", { bindingId: id });
+		const now = /* @__PURE__ */ new Date();
+		const removedAt = existing.removedAt ?? now;
+		this.db.prepare("update heph_skill_bindings set status = 'removed', updated_at = ?, removed_at = ? where id = ?").run(toIso(now), toIso(removedAt), id);
+		return {
+			...existing,
+			status: "removed",
+			updatedAt: now,
+			removedAt
+		};
+	}
+	async createApprovalRequest(input) {
+		const now = /* @__PURE__ */ new Date();
+		const request = {
+			id: input.id ?? createApprovalRequestId(),
+			agentId: input.agentId,
+			runId: input.runId,
+			toolId: input.toolId,
+			input: clonePlain(input.input),
+			status: "pending",
+			requestedBy: input.requestedBy ?? null,
+			decidedBy: null,
+			metadata: input.metadata ?? {},
+			createdAt: now,
+			updatedAt: now,
+			decidedAt: null
+		};
+		this.db.prepare(`insert into heph_approval_requests
+          (id, agent_id, run_id, tool_id, input_json, status, requested_by_json, decided_by_json,
+           metadata_json, created_at, updated_at, decided_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(request.id, request.agentId, request.runId, request.toolId, stringifyJson(request.input), request.status, stringifyJson(request.requestedBy), stringifyJson(request.decidedBy), stringifyJson(request.metadata), toIso(request.createdAt), toIso(request.updatedAt), toIsoOrNull(request.decidedAt));
+		return clonePlain(request);
+	}
+	async getApprovalRequest(id) {
+		const row = this.db.prepare("select * from heph_approval_requests where id = ?").get(id);
+		return row ? rowToApprovalRequest(row) : null;
+	}
+	async listApprovalRequests(runId, options = {}) {
+		const params = [runId];
+		let sql = "select * from heph_approval_requests where run_id = ?";
+		const status = options.status ?? "all";
+		if (status !== "all") {
+			sql += " and status = ?";
+			params.push(status);
+		}
+		sql += " order by created_at asc, id asc";
+		return this.db.prepare(sql).all(...params).map((row) => rowToApprovalRequest(row));
+	}
+	async decideApprovalRequest(input) {
+		const existing = await this.getApprovalRequest(input.id);
+		if (!existing) throw notFound("ApprovalRequest not found", { approvalRequestId: input.id });
+		const now = /* @__PURE__ */ new Date();
+		const updated = {
+			...existing,
+			status: input.decision,
+			decidedBy: input.decidedBy ?? null,
+			metadata: {
+				...existing.metadata,
+				...input.metadata ?? {}
+			},
+			updatedAt: now,
+			decidedAt: now
+		};
+		this.db.prepare(`update heph_approval_requests
+         set status = ?, decided_by_json = ?, metadata_json = ?, updated_at = ?, decided_at = ?
+         where id = ?`).run(updated.status, stringifyJson(updated.decidedBy), stringifyJson(updated.metadata), toIso(updated.updatedAt), toIsoOrNull(updated.decidedAt), input.id);
+		return clonePlain(updated);
+	}
+	async createDeferredToolOperation(input) {
+		const now = /* @__PURE__ */ new Date();
+		const operation = {
+			id: input.id ?? createDeferredToolOperationId(),
+			agentId: input.agentId,
+			runId: input.runId,
+			toolId: input.toolId,
+			toolCallId: input.toolCallId ?? null,
+			status: "pending",
+			resumePolicy: input.resumePolicy ?? "auto",
+			auth: input.auth ?? null,
+			result: null,
+			error: null,
+			metadata: input.metadata ?? {},
+			createdAt: now,
+			updatedAt: now,
+			completedAt: null
+		};
+		this.db.prepare(`insert into heph_deferred_tool_operations
+          (id, agent_id, run_id, tool_id, tool_call_id, status, resume_policy, auth_json,
+           result_json, error_json, metadata_json, created_at, updated_at, completed_at)
+         values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(operation.id, operation.agentId, operation.runId, operation.toolId, operation.toolCallId, operation.status, operation.resumePolicy, stringifyJson(operation.auth), stringifyJson(operation.result), stringifyJson(operation.error), stringifyJson(operation.metadata), toIso(operation.createdAt), toIso(operation.updatedAt), toIsoOrNull(operation.completedAt));
+		return clonePlain(operation);
+	}
+	async getDeferredToolOperation(id) {
+		const row = this.db.prepare("select * from heph_deferred_tool_operations where id = ?").get(id);
+		return row ? rowToDeferredToolOperation(row) : null;
+	}
+	async completeDeferredToolOperation(input) {
+		const existing = await this.getDeferredToolOperation(input.id);
+		if (!existing) throw notFound("DeferredToolOperation not found", { operationId: input.id });
+		if (existing.status !== "pending") return clonePlain(existing);
+		const now = /* @__PURE__ */ new Date();
+		const updated = {
+			...existing,
+			status: input.status,
+			result: input.result ?? null,
+			error: input.error ?? null,
+			metadata: {
+				...existing.metadata,
+				...input.metadata ?? {}
+			},
+			updatedAt: now,
+			completedAt: now
+		};
+		this.db.prepare(`update heph_deferred_tool_operations
+         set status = ?, result_json = ?, error_json = ?, metadata_json = ?, updated_at = ?, completed_at = ?
+         where id = ?`).run(updated.status, stringifyJson(updated.result), stringifyJson(updated.error), stringifyJson(updated.metadata), toIso(updated.updatedAt), toIsoOrNull(updated.completedAt), input.id);
+		return clonePlain(updated);
+	}
+};
+var SQLiteQueue = class {
+	db;
+	concurrency;
+	pollIntervalMs;
+	leaseMs;
+	retryDelayMs;
+	maxAttempts;
+	onError;
+	activeAgents = /* @__PURE__ */ new Set();
+	idleResolvers = /* @__PURE__ */ new Set();
+	activeCount = 0;
+	handler = null;
+	timer = null;
+	constructor(db, options = { databasePath: ":memory:" }) {
+		this.db = db;
+		this.concurrency = options.concurrency ?? 4;
+		this.pollIntervalMs = options.pollIntervalMs ?? 50;
+		this.leaseMs = options.leaseMs ?? 3e4;
+		this.retryDelayMs = options.retryDelayMs ?? 1e3;
+		this.maxAttempts = options.maxAttempts ?? 5;
+		this.onError = options.onError ?? ((error, job) => {
+			console.error("Unhandled Heph SQLite queue error", {
+				error,
+				job
+			});
+		});
+	}
+	close() {
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		this.db.close();
+	}
+	async enqueue(job, options = {}) {
+		const now = /* @__PURE__ */ new Date();
+		const availableAt = new Date(now.getTime() + (options.delayMs ?? 0));
+		const idempotencyKey = options.idempotencyKey ?? null;
+		const id = idempotencyKey ?? `queue_${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}_${Math.random()}`}`;
+		this.db.prepare(`insert into heph_queue_jobs
+          (id, idempotency_key, type, agent_id, run_id, job_json, status, attempt, max_attempts,
+           available_at, leased_until, created_at, updated_at, last_error_json)
+         values (?, ?, ?, ?, ?, ?, 'available', 0, ?, ?, null, ?, ?, null)
+         on conflict(id) do nothing`).run(id, idempotencyKey, job.type, job.agentId, "runId" in job ? job.runId : null, stringifyJson(job), this.maxAttempts, toIso(availableAt), toIso(now), toIso(now));
+		this.schedule(0);
+	}
+	async startConsumer(handler) {
+		this.handler = handler;
+		this.schedule(0);
+	}
+	async onIdle() {
+		if (this.isIdle()) return;
+		await new Promise((resolve) => {
+			this.idleResolvers.add(resolve);
+		});
+	}
+	schedule(delayMs = this.pollIntervalMs) {
+		if (!this.handler || this.timer) return;
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.pump();
+		}, delayMs);
+		this.timer.unref?.();
+	}
+	pump() {
+		if (!this.handler) {
+			this.resolveIdleIfNeeded();
+			return;
+		}
+		while (this.activeCount < this.concurrency) {
+			const row = this.claimNextJob();
+			if (!row) break;
+			const job = parseJson(row.job_json);
+			this.activeCount += 1;
+			this.activeAgents.add(row.agent_id);
+			this.handler(job).then(() => {
+				this.markDone(row.id);
+			}).catch((error) => {
+				this.onError(error, job);
+				this.markRetryOrFailed(row, error);
+			}).finally(() => {
+				this.activeCount -= 1;
+				this.activeAgents.delete(row.agent_id);
+				this.resolveIdleIfNeeded();
+				this.schedule(0);
+			});
+		}
+		this.resolveIdleIfNeeded();
+		this.schedule();
+	}
+	claimNextJob() {
+		return this.db.transaction(() => {
+			const now = /* @__PURE__ */ new Date();
+			const row = this.db.prepare(`select * from heph_queue_jobs
+           where ((status = 'available' and available_at <= ?) or (status = 'leased' and leased_until <= ?))
+             and not exists (
+               select 1 from heph_queue_jobs active
+               where active.agent_id = heph_queue_jobs.agent_id
+                 and active.status = 'leased'
+                 and active.leased_until > ?
+             )
+           order by available_at asc, id asc
+           limit 50`).all(toIso(now), toIso(now), toIso(now)).find((candidate) => !this.activeAgents.has(candidate.agent_id));
+			if (!row) return null;
+			const leasedUntil = new Date(now.getTime() + this.leaseMs);
+			this.db.prepare(`update heph_queue_jobs
+           set status = 'leased', attempt = attempt + 1, leased_until = ?, updated_at = ?
+           where id = ?`).run(toIso(leasedUntil), toIso(now), row.id);
+			return {
+				...row,
+				status: "leased",
+				attempt: row.attempt + 1,
+				leased_until: toIso(leasedUntil),
+				updated_at: toIso(now)
+			};
+		})();
+	}
+	markDone(id) {
+		this.db.prepare("update heph_queue_jobs set status = 'done', updated_at = ? where id = ?").run(toIso(/* @__PURE__ */ new Date()), id);
+	}
+	markRetryOrFailed(row, error) {
+		const now = /* @__PURE__ */ new Date();
+		const status = row.attempt >= row.max_attempts ? "failed" : "available";
+		const availableAt = row.attempt >= row.max_attempts ? row.available_at : toIso(new Date(now.getTime() + this.retryDelayMs));
+		this.db.prepare(`update heph_queue_jobs
+         set status = ?, available_at = ?, leased_until = null, updated_at = ?, last_error_json = ?
+         where id = ?`).run(status, availableAt, toIso(now), stringifyJson(toErrorDetails(error)), row.id);
+	}
+	isIdle() {
+		if (this.activeCount > 0) return false;
+		return this.db.prepare("select count(*) as count from heph_queue_jobs where status in ('available', 'leased')").get().count === 0;
+	}
+	resolveIdleIfNeeded() {
+		if (!this.isIdle()) return;
+		for (const resolve of this.idleResolvers) resolve();
+		this.idleResolvers.clear();
+	}
+};
+function openDatabase(options) {
+	if (options.databasePath !== ":memory:") mkdirSync(dirname(options.databasePath), { recursive: true });
+	const db = new BetterSqlite3(options.databasePath);
+	db.pragma("journal_mode = WAL");
+	db.pragma("foreign_keys = ON");
+	db.pragma("busy_timeout = 5000");
+	handleMigrations(db, options.migrations);
+	return db;
+}
+function handleMigrations(db, options) {
+	const mode = options?.mode ?? "apply";
+	if (mode === "none") return;
+	if (mode === "write_out") {
+		writeSQLiteMigration(options?.outputDir ?? DEFAULT_MIGRATION_OUTPUT_DIR);
+		return;
+	}
+	db.exec(INITIAL_MIGRATION_SQL);
+	ensureSQLiteSchemaCompatibility(db);
+	db.prepare(`insert into heph_schema_migrations (version, name, applied_at)
+     values (?, ?, ?)
+     on conflict(version) do nothing`).run(INITIAL_MIGRATION_VERSION, "Initial Heph SQLite schema", toIso(/* @__PURE__ */ new Date()));
+}
+function ensureSQLiteSchemaCompatibility(db) {
+	const runColumns = db.prepare("pragma table_info(heph_runs)").all();
+	if (!runColumns.some((column) => column.name === "skill_manifest_json")) db.exec("alter table heph_runs add column skill_manifest_json text");
+	if (!runColumns.some((column) => column.name === "tool_manifest_json")) db.exec("alter table heph_runs add column tool_manifest_json text");
+	db.exec(DEFERRED_TOOL_OPERATIONS_SQL);
+}
+function rowToAgentSession(row) {
+	return {
+		id: row.id,
+		agentSpecId: row.agent_spec_id,
+		agentSpecVersion: row.agent_spec_version,
+		state: parseJson(row.state_json),
+		activeRunId: row.active_run_id,
+		auth: parseNullableJson(row.auth_json),
+		metadata: parseJson(row.metadata_json),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at)
+	};
+}
+function rowToRun(row) {
+	return {
+		id: row.id,
+		agentId: row.agent_id,
+		agentSpecId: row.agent_spec_id,
+		agentSpecVersion: row.agent_spec_version,
+		status: row.status,
+		input: parseJson(row.input_json),
+		auth: parseNullableJson(row.auth_json),
+		contextManifest: parseNullableJson(row.context_manifest_json),
+		skillManifest: parseSkillManifest(row.skill_manifest_json),
+		toolManifest: parseToolManifest(row.tool_manifest_json),
+		error: parseNullableJson(row.error_json),
+		metadata: parseJson(row.metadata_json),
+		queuedAt: parseDate(row.queued_at),
+		startedAt: parseNullableDate(row.started_at),
+		completedAt: parseNullableDate(row.completed_at),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at)
+	};
+}
+function rowToMessage(row) {
+	return {
+		id: row.id,
+		agentId: row.agent_id,
+		role: row.role,
+		content: row.content,
+		sourceRunId: row.source_run_id,
+		auth: parseNullableJson(row.auth_json),
+		metadata: parseJson(row.metadata_json),
+		createdAt: parseDate(row.created_at)
+	};
+}
+function rowToInboxEvent(row) {
+	return {
+		id: row.id,
+		agentId: row.agent_id,
+		type: row.type,
+		input: parseJson(row.input_json),
+		status: row.status,
+		runId: row.run_id,
+		auth: parseNullableJson(row.auth_json),
+		metadata: parseJson(row.metadata_json),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at),
+		claimedAt: parseNullableDate(row.claimed_at),
+		processedAt: parseNullableDate(row.processed_at),
+		failedAt: parseNullableDate(row.failed_at),
+		error: parseNullableJson(row.error_json)
+	};
+}
+function rowToRunEvent(row) {
+	return {
+		id: row.id,
+		runId: row.run_id,
+		seq: row.seq,
+		type: row.type,
+		payload: parseJson(row.payload_json),
+		sourceRefs: parseJson(row.source_refs_json),
+		createdAt: parseDate(row.created_at)
+	};
+}
+function rowToMemoryItem(row) {
+	return {
+		id: row.id,
+		scope: {
+			type: row.scope_type,
+			id: row.scope_id
+		},
+		kind: row.kind,
+		content: row.content,
+		sourceRefs: parseJson(row.source_refs_json),
+		importance: row.importance,
+		confidence: row.confidence,
+		embeddingRef: row.embedding_ref,
+		expiresAt: parseNullableDate(row.expires_at),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at)
+	};
+}
+function rowToMcpBinding(row) {
+	return {
+		id: row.id,
+		agentId: row.agent_id,
+		capabilityId: row.capability_id,
+		accountRef: row.account_ref,
+		allowTools: parseJson(row.allow_tools_json),
+		status: row.status,
+		metadata: parseJson(row.metadata_json),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at),
+		removedAt: parseNullableDate(row.removed_at)
+	};
+}
+function rowToSkillBinding(row) {
+	return {
+		id: row.id,
+		agentId: row.agent_id,
+		skillId: row.skill_id,
+		name: row.name,
+		version: row.version,
+		source: parseJson(row.source_json),
+		allowReferences: parseJson(row.allow_references_json),
+		status: row.status,
+		metadata: parseJson(row.metadata_json),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at),
+		removedAt: parseNullableDate(row.removed_at)
+	};
+}
+function rowToApprovalRequest(row) {
+	return {
+		id: row.id,
+		agentId: row.agent_id,
+		runId: row.run_id,
+		toolId: row.tool_id,
+		input: parseNullableJson(row.input_json),
+		status: row.status,
+		requestedBy: parseNullableJson(row.requested_by_json),
+		decidedBy: parseNullableJson(row.decided_by_json),
+		metadata: parseJson(row.metadata_json),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at),
+		decidedAt: parseNullableDate(row.decided_at)
+	};
+}
+function rowToDeferredToolOperation(row) {
+	return {
+		id: row.id,
+		agentId: row.agent_id,
+		runId: row.run_id,
+		toolId: row.tool_id,
+		toolCallId: row.tool_call_id,
+		status: row.status,
+		resumePolicy: row.resume_policy,
+		auth: parseNullableJson(row.auth_json),
+		result: parseNullableJson(row.result_json),
+		error: parseNullableJson(row.error_json),
+		metadata: parseJson(row.metadata_json),
+		createdAt: parseDate(row.created_at),
+		updatedAt: parseDate(row.updated_at),
+		completedAt: parseNullableDate(row.completed_at)
+	};
+}
+function scoreMemory(item, query) {
+	const importance = item.importance ?? .5;
+	const confidence = item.confidence ?? .5;
+	const content = item.content.toLowerCase();
+	const queryScore = query && content.includes(query) ? 2 : 0;
+	return importance + confidence + queryScore;
+}
+function sameScope(a, b) {
+	return a.type === b.type && a.id === b.id;
+}
+function notFound(message, details) {
+	return new HephError({
+		code: "HEPH5001",
+		title: message,
+		message,
+		status: 404,
+		details
+	});
+}
+function toErrorDetails(error) {
+	if (error instanceof Error) return {
+		name: error.name,
+		message: error.message
+	};
+	return { message: String(error) };
+}
+function stringifyJson(value) {
+	return value === null ? null : JSON.stringify(value);
+}
+function parseJson(value) {
+	return JSON.parse(value);
+}
+function parseNullableJson(value) {
+	return value === null ? null : parseJson(value);
+}
+function toIso(value) {
+	return value.toISOString();
+}
+function toIsoOrNull(value) {
+	return value ? value.toISOString() : null;
+}
+function parseDate(value) {
+	return new Date(value);
+}
+function parseNullableDate(value) {
+	return value ? parseDate(value) : null;
+}
+function parseToolManifest(value) {
+	const manifest = parseNullableJson(value);
+	if (!manifest) return null;
+	return {
+		...manifest,
+		createdAt: new Date(manifest.createdAt)
+	};
+}
+function parseSkillManifest(value) {
+	const manifest = parseNullableJson(value);
+	if (!manifest) return null;
+	return {
+		...manifest,
+		createdAt: new Date(manifest.createdAt)
+	};
+}
+function clonePlain(value) {
+	return structuredClone(value);
+}
+const DEFERRED_TOOL_OPERATIONS_SQL = `
+create table if not exists heph_deferred_tool_operations (
+  id text primary key,
+  agent_id text not null,
+  run_id text not null,
+  tool_id text not null,
+  tool_call_id text,
+  status text not null,
+  resume_policy text not null,
+  auth_json text,
+  result_json text,
+  error_json text,
+  metadata_json text not null,
+  created_at text not null,
+  updated_at text not null,
+  completed_at text
+);
+
+create index if not exists idx_heph_deferred_tool_operations_run on heph_deferred_tool_operations(run_id, created_at);
+create index if not exists idx_heph_deferred_tool_operations_agent_status on heph_deferred_tool_operations(agent_id, status, created_at);
+`;
+const INITIAL_MIGRATION_SQL = `
+create table if not exists heph_schema_migrations (
+  version text primary key,
+  name text not null,
+  applied_at text not null
+);
+
+create table if not exists heph_agent_sessions (
+  id text primary key,
+  agent_spec_id text not null,
+  agent_spec_version text,
+  state_json text not null,
+  active_run_id text,
+  auth_json text,
+  metadata_json text not null,
+  created_at text not null,
+  updated_at text not null
+);
+
+create index if not exists idx_heph_agent_sessions_spec on heph_agent_sessions(agent_spec_id);
+
+create table if not exists heph_runs (
+  id text primary key,
+  agent_id text not null,
+  agent_spec_id text not null,
+  agent_spec_version text,
+  status text not null,
+  input_json text not null,
+  auth_json text,
+  context_manifest_json text,
+  skill_manifest_json text,
+  tool_manifest_json text,
+  error_json text,
+  metadata_json text not null,
+  queued_at text not null,
+  started_at text,
+  completed_at text,
+  created_at text not null,
+  updated_at text not null
+);
+
+create index if not exists idx_heph_runs_agent_created on heph_runs(agent_id, created_at);
+create index if not exists idx_heph_runs_status on heph_runs(status);
+
+create table if not exists heph_messages (
+  id text primary key,
+  agent_id text not null,
+  role text not null,
+  content text not null,
+  source_run_id text,
+  auth_json text,
+  metadata_json text not null,
+  created_at text not null
+);
+
+create index if not exists idx_heph_messages_agent_created on heph_messages(agent_id, created_at);
+
+create table if not exists heph_inbox_events (
+  id text primary key,
+  agent_id text not null,
+  type text not null,
+  input_json text not null,
+  status text not null,
+  run_id text,
+  auth_json text,
+  metadata_json text not null,
+  created_at text not null,
+  updated_at text not null,
+  claimed_at text,
+  claim_lease_until text,
+  processed_at text,
+  failed_at text,
+  error_json text,
+  attempt integer not null default 0
+);
+
+create index if not exists idx_heph_inbox_agent_status_created on heph_inbox_events(agent_id, status, created_at);
+create index if not exists idx_heph_inbox_lease on heph_inbox_events(status, claim_lease_until);
+
+create table if not exists heph_run_events (
+  id text primary key,
+  run_id text not null,
+  seq integer not null,
+  type text not null,
+  payload_json text not null,
+  source_refs_json text not null,
+  created_at text not null,
+  unique(run_id, seq)
+);
+
+create index if not exists idx_heph_run_events_run_seq on heph_run_events(run_id, seq);
+
+create table if not exists heph_memory_items (
+  id text primary key,
+  scope_type text not null,
+  scope_id text not null,
+  kind text not null,
+  content text not null,
+  source_refs_json text not null,
+  importance real,
+  confidence real,
+  embedding_ref text,
+  expires_at text,
+  created_at text not null,
+  updated_at text not null
+);
+
+create index if not exists idx_heph_memory_scope on heph_memory_items(scope_type, scope_id);
+create index if not exists idx_heph_memory_expires on heph_memory_items(expires_at);
+
+create table if not exists heph_mcp_bindings (
+  id text primary key,
+  agent_id text not null,
+  capability_id text not null,
+  account_ref text,
+  allow_tools_json text not null,
+  status text not null,
+  metadata_json text not null,
+  created_at text not null,
+  updated_at text not null,
+  removed_at text
+);
+
+create index if not exists idx_heph_mcp_bindings_agent_status on heph_mcp_bindings(agent_id, status, created_at);
+create index if not exists idx_heph_mcp_bindings_capability on heph_mcp_bindings(capability_id);
+
+create table if not exists heph_skill_bindings (
+  id text primary key,
+  agent_id text not null,
+  skill_id text not null,
+  name text not null,
+  version text,
+  source_json text not null,
+  allow_references_json text not null,
+  status text not null,
+  metadata_json text not null,
+  created_at text not null,
+  updated_at text not null,
+  removed_at text
+);
+
+create index if not exists idx_heph_skill_bindings_agent_status on heph_skill_bindings(agent_id, status, created_at);
+create index if not exists idx_heph_skill_bindings_skill on heph_skill_bindings(skill_id);
+
+create table if not exists heph_approval_requests (
+  id text primary key,
+  agent_id text not null,
+  run_id text not null,
+  tool_id text not null,
+  input_json text,
+  status text not null,
+  requested_by_json text,
+  decided_by_json text,
+  metadata_json text not null,
+  created_at text not null,
+  updated_at text not null,
+  decided_at text
+);
+
+create index if not exists idx_heph_approval_requests_run_status on heph_approval_requests(run_id, status, created_at);
+create index if not exists idx_heph_approval_requests_agent on heph_approval_requests(agent_id, created_at);
+
+${DEFERRED_TOOL_OPERATIONS_SQL}
+
+create table if not exists heph_queue_jobs (
+  id text primary key,
+  idempotency_key text unique,
+  type text not null,
+  agent_id text not null,
+  run_id text,
+  job_json text not null,
+  status text not null,
+  attempt integer not null default 0,
+  max_attempts integer not null,
+  available_at text not null,
+  leased_until text,
+  created_at text not null,
+  updated_at text not null,
+  last_error_json text
+);
+
+create index if not exists idx_heph_queue_available on heph_queue_jobs(status, available_at);
+create index if not exists idx_heph_queue_lease on heph_queue_jobs(status, leased_until);
+create index if not exists idx_heph_queue_agent on heph_queue_jobs(agent_id, status);
+`;
+//#endregion
+export { SQLiteHephStore, SQLiteQueue, createSQLiteAdapters, createSQLiteHephStore, createSQLiteQueue, writeSQLiteMigration };
+
+//# sourceMappingURL=sqlite.mjs.map