@otakumesi/heph 0.0.1

package/dist/src-DeheByi4.mjs

@@ -0,0 +1,2677 @@
+import { z } from "zod";
+//#region ../core/src/errors.ts
+var HephError = class extends Error {
+	code;
+	title;
+	details;
+	status;
+	constructor(options) {
+		super(options.message ?? options.title, hasCause(options) ? { cause: options.cause } : void 0);
+		this.name = "HephError";
+		this.code = options.code;
+		this.title = options.title;
+		if (options.details !== void 0) this.details = options.details;
+		if (options.status !== void 0) this.status = options.status;
+	}
+};
+function isHephError(error) {
+	return error instanceof HephError;
+}
+function toErrorDetails(error) {
+	if (error instanceof Error) return {
+		name: error.name,
+		message: error.message
+	};
+	return { message: String(error) };
+}
+function hasCause(options) {
+	return "cause" in options;
+}
+//#endregion
+//#region ../core/src/context.ts
+var ContextRenderer = class {
+	render(options) {
+		const slotValues = /* @__PURE__ */ new Map();
+		const manifestBlocks = [];
+		for (const block of options.blocks) {
+			const slot = options.template.slots[block.key];
+			const originalTokens = estimateTokens(block.content);
+			const truncatedContent = slot?.maxTokens ? truncateToTokens(block.content, slot.maxTokens) : block.content;
+			const tokens = estimateTokens(truncatedContent);
+			const existing = slotValues.get(block.key);
+			slotValues.set(block.key, existing ? `${existing}\n\n${truncatedContent}` : truncatedContent);
+			manifestBlocks.push({
+				key: block.key,
+				type: block.type,
+				tokens,
+				sourceRefs: block.sourceRefs ?? [],
+				truncated: tokens < originalTokens
+			});
+		}
+		for (const [key, slot] of Object.entries(options.template.slots)) {
+			const value = slotValues.get(key);
+			if (slot.required && isBlank(value)) throw new HephError({
+				code: "HEPH2001",
+				title: "Required context slot is missing",
+				message: `Context template ${options.template.id} requires slot ${key}.`,
+				status: 422,
+				details: {
+					templateId: options.template.id,
+					slot: key
+				}
+			});
+		}
+		const messages = options.template.messages.map((message) => ({
+			role: message.role,
+			content: interpolate(message.content, {
+				input: options.input,
+				runtime: options.runtime ?? {},
+				slots: slotValues
+			}).trim()
+		}));
+		return {
+			messages,
+			manifest: {
+				runId: options.runId,
+				contextTemplateId: options.template.id,
+				contextTemplateVersion: options.template.version,
+				blocks: manifestBlocks,
+				totalTokens: messages.reduce((sum, message) => sum + estimateTokens(message.content), 0),
+				createdAt: /* @__PURE__ */ new Date()
+			}
+		};
+	}
+};
+const defaultContextTemplate = {
+	id: "default",
+	version: "0.1.0",
+	slots: {
+		runtimePolicy: { required: true },
+		agentIdentity: { required: true },
+		developerRules: { maxTokens: 1200 },
+		currentTask: {
+			required: true,
+			maxTokens: 1200
+		},
+		sessionState: {
+			required: true,
+			maxTokens: 1500
+		},
+		openTasks: { maxTokens: 1e3 },
+		pendingApprovals: { maxTokens: 800 },
+		skills: { maxTokens: 2e3 },
+		memories: { maxTokens: 2e3 },
+		condensedHistory: { maxTokens: 2e3 },
+		recentMessages: { maxTokens: 3e3 },
+		domainContext: { maxTokens: 2500 },
+		workspaceContext: { maxTokens: 2500 },
+		artifacts: { maxTokens: 1500 },
+		teamContext: { maxTokens: 1500 },
+		toolManifest: {
+			required: true,
+			maxTokens: 2500
+		},
+		outputContract: { maxTokens: 1e3 }
+	},
+	messages: [
+		{
+			role: "system",
+			content: `
+{{ runtimePolicy }}
+
+{{ agentIdentity }}
+`
+		},
+		{
+			role: "developer",
+			content: `
+Developer rules:
+{{ developerRules }}
+
+Tool and safety policy:
+{{ runtime.toolPolicy }}
+
+Output contract:
+{{ outputContract }}
+`
+		},
+		{
+			role: "user",
+			content: `
+Current task:
+{{ currentTask }}
+
+Current session state:
+{{ sessionState }}
+
+Open tasks:
+{{ openTasks }}
+
+Pending approvals or blocked actions:
+{{ pendingApprovals }}
+
+Active skills:
+{{ skills }}
+
+Relevant memory:
+{{ memories }}
+
+Condensed prior history:
+{{ condensedHistory }}
+
+Recent conversation:
+{{ recentMessages }}
+
+Domain context:
+{{ domainContext }}
+
+Workspace context:
+{{ workspaceContext }}
+
+Relevant artifacts:
+{{ artifacts }}
+
+Team context:
+{{ teamContext }}
+
+Available tools for this Run:
+{{ toolManifest }}
+
+User input:
+{{ input }}
+`
+		}
+	]
+};
+function estimateTokens(content) {
+	if (!content) return 0;
+	return Math.max(1, Math.ceil(content.length / 4));
+}
+function truncateToTokens(content, maxTokens) {
+	const maxChars = Math.max(0, maxTokens * 4);
+	if (content.length <= maxChars) return content;
+	return `${content.slice(0, Math.max(0, maxChars - 16)).trimEnd()}\n[truncated]`;
+}
+function interpolate(template, values) {
+	return template.replaceAll(/\{\{\s*([\w.]+)\s*\}\}/g, (_match, key) => {
+		if (key === "input") return values.input;
+		if (key.startsWith("runtime.")) return values.runtime[key.slice(8)] ?? "";
+		return values.slots.get(key) ?? "";
+	});
+}
+function isBlank(value) {
+	return value === void 0 || value.trim().length === 0;
+}
+function messagesToText(messages) {
+	return messages.map((message) => `${message.role}: ${message.content}`).join("\n\n");
+}
+//#endregion
+//#region ../core/src/definitions.ts
+function defineAgent(definition) {
+	return {
+		id: definition.id,
+		version: definition.version ?? null,
+		instructions: definition.instructions,
+		model: definition.model ?? null,
+		tools: definition.tools ?? [],
+		mcp: normalizeMcpPolicy(definition.mcp, definition.allowAllMcpTools),
+		skills: normalizeSkillPolicy(definition.skills),
+		contextProviders: [...definition.contextProviders ?? [], ...definition.context ?? []],
+		contextTemplate: definition.contextTemplate ?? null,
+		metadata: definition.metadata ?? {}
+	};
+}
+function normalizeMcpPolicy(policy, allowAllTools) {
+	if (policy === void 0 || policy === null) return null;
+	if (Array.isArray(policy)) {
+		const normalized = { allowCapabilities: policy };
+		if (allowAllTools !== void 0) normalized.allowAllTools = allowAllTools;
+		return normalized;
+	}
+	if (allowAllTools !== void 0) return {
+		...policy,
+		allowAllTools
+	};
+	return policy;
+}
+function normalizeSkillPolicy(policy) {
+	if (policy === void 0 || policy === null) return null;
+	if (policy === "all") return { allow: "all" };
+	if (Array.isArray(policy)) return { allow: policy };
+	return policy;
+}
+function defineContextProvider(definition) {
+	return {
+		id: definition.id,
+		load: definition.load
+	};
+}
+function defineContextTemplate(template) {
+	return template;
+}
+function defineTool(definition) {
+	const jsonSchema = toJsonSchema(definition.id, definition.inputSchema);
+	const tool = {
+		id: definition.id,
+		description: definition.description,
+		inputSchema: definition.inputSchema,
+		jsonSchema,
+		sideEffect: definition.sideEffect ?? false,
+		requiresApproval: definition.requiresApproval ?? false,
+		execute: definition.execute
+	};
+	if (definition.concurrencyKey !== void 0) tool.concurrencyKey = definition.concurrencyKey;
+	return tool;
+}
+const AgentSpec = { define: defineAgent };
+const ContextProvider = { define: defineContextProvider };
+const ContextTemplate = { define: defineContextTemplate };
+const Tool = { define: defineTool };
+function toJsonSchema(toolId, schema) {
+	try {
+		return z.toJSONSchema(schema);
+	} catch (cause) {
+		throw new HephError({
+			code: "HEPH3001",
+			title: "Tool schema is not JSON Schema representable",
+			message: `Tool ${toolId} uses a Zod schema that cannot be exposed to the model.`,
+			status: 422,
+			details: { toolId },
+			cause
+		});
+	}
+}
+//#endregion
+//#region ../core/src/executor.ts
+var MinimalRunExecutor = class {
+	async execute(ctx) {
+		await ctx.emit({
+			type: "turn.started",
+			payload: { executor: "minimal" }
+		});
+		const text = runInputText$1(ctx.run.input);
+		const response = text ? `Minimal executor received: ${text}` : "Minimal executor completed the run.";
+		await ctx.emit({
+			type: "message.started",
+			payload: { role: "assistant" }
+		});
+		await ctx.emit({
+			type: "message.delta",
+			payload: { text: response }
+		});
+		const message = await ctx.appendMessage({
+			role: "assistant",
+			content: response,
+			sourceRunId: ctx.run.id,
+			metadata: { executor: "minimal" }
+		});
+		await ctx.emit({
+			type: "message.completed",
+			payload: {
+				messageId: message.id,
+				role: message.role,
+				content: message.content
+			},
+			sourceRefs: [{
+				type: "message",
+				id: message.id
+			}]
+		});
+		await ctx.emit({
+			type: "turn.completed",
+			payload: { executor: "minimal" }
+		});
+	}
+};
+function runInputText$1(input) {
+	return "text" in input ? input.text : "";
+}
+//#endregion
+//#region ../core/src/ids.ts
+let fallbackCounter = 0;
+function createId(prefix) {
+	const randomId = globalThis.crypto?.randomUUID?.();
+	if (randomId) return `${prefix}${randomId.replaceAll("-", "")}`;
+	fallbackCounter += 1;
+	return `${prefix}${Date.now().toString(36)}${fallbackCounter.toString(36)}`;
+}
+function createAgentSessionId() {
+	return createId("agent_");
+}
+function createRunId() {
+	return createId("run_");
+}
+function createMessageId() {
+	return createId("msg_");
+}
+function createRunEventId() {
+	return createId("evt_");
+}
+function createMemoryId() {
+	return createId("mem_");
+}
+function createInboxEventId() {
+	return createId("inbox_");
+}
+function createDeferredToolOperationId() {
+	return createId("op_");
+}
+function createMcpBindingId() {
+	return createId("mcpbind_");
+}
+function createSkillBindingId() {
+	return createId("skillbind_");
+}
+function createApprovalRequestId() {
+	return createId("approval_");
+}
+//#endregion
+//#region ../core/src/providers.ts
+function recentMessages(options = {}) {
+	const limit = options.limit ?? 20;
+	return defineContextProvider({
+		id: "recent-messages",
+		async load(ctx) {
+			const messages = await ctx.stores.messages.listMessages(ctx.agent.id, { limit });
+			if (messages.length === 0) return null;
+			return {
+				key: "recentMessages",
+				type: "message_history",
+				content: formatMessages(messages),
+				sourceRefs: messages.map((message) => ({
+					type: "message",
+					id: message.id
+				}))
+			};
+		}
+	});
+}
+function threadState() {
+	return defineContextProvider({
+		id: "thread-state",
+		async load(ctx) {
+			return {
+				key: "sessionState",
+				type: "state",
+				content: JSON.stringify(ctx.agent.state, null, 2)
+			};
+		}
+	});
+}
+function memorySearch(options = {}) {
+	const topK = options.topK ?? 8;
+	return defineContextProvider({
+		id: "memory-search",
+		async load(ctx) {
+			const query = "text" in ctx.input ? ctx.input.text : void 0;
+			const searchInput = {
+				scopes: options.scopes ?? defaultMemoryScopes(ctx.agent.id, ctx.spec.id, ctx.auth?.userId),
+				topK
+			};
+			const memories = await ctx.stores.memory.searchMemory(query === void 0 ? searchInput : {
+				...searchInput,
+				query
+			});
+			if (memories.length === 0) return null;
+			return {
+				key: "memories",
+				type: "memory",
+				content: memories.map((memory) => {
+					const sourceRefs = memory.sourceRefs.map((ref) => `${ref.type}:${ref.id}`).join(", ");
+					return `- [${memory.kind}] ${memory.content} (sourceRefs: ${sourceRefs})`;
+				}).join("\n"),
+				sourceRefs: memories.map((memory) => ({
+					type: "memory",
+					id: memory.id
+				}))
+			};
+		}
+	});
+}
+function formatMessages(messages) {
+	return messages.map((message) => `${message.role}: ${message.content}`).join("\n");
+}
+function defaultMemoryScopes(sessionId, agentSpecId, userId) {
+	const scopes = [{
+		type: "session",
+		id: sessionId
+	}, {
+		type: "agent",
+		id: agentSpecId
+	}];
+	if (userId) scopes.push({
+		type: "user",
+		id: userId
+	});
+	return scopes;
+}
+function block(block) {
+	return block;
+}
+//#endregion
+//#region ../core/src/queue.ts
+var InProcessQueue = class {
+	concurrency;
+	onError;
+	jobs = [];
+	activeAgents = /* @__PURE__ */ new Set();
+	idleResolvers = /* @__PURE__ */ new Set();
+	activeCount = 0;
+	scheduled = false;
+	handler = null;
+	constructor(options = {}) {
+		this.concurrency = options.concurrency ?? 4;
+		this.onError = options.onError ?? ((error, job) => {
+			console.error("Unhandled Heph in-process queue error", {
+				error,
+				job
+			});
+		});
+	}
+	async startConsumer(handler) {
+		this.handler = handler;
+		this.schedule();
+	}
+	async enqueue(job) {
+		this.jobs.push(job);
+		this.schedule();
+	}
+	async onIdle() {
+		if (this.isIdle()) return;
+		await new Promise((resolve) => {
+			this.idleResolvers.add(resolve);
+		});
+	}
+	schedule() {
+		if (this.scheduled) return;
+		this.scheduled = true;
+		queueMicrotask(() => {
+			this.scheduled = false;
+			this.pump();
+		});
+	}
+	pump() {
+		if (!this.handler) {
+			this.resolveIdleIfNeeded();
+			return;
+		}
+		while (this.activeCount < this.concurrency) {
+			const index = this.jobs.findIndex((job) => !this.activeAgents.has(job.agentId));
+			if (index === -1) break;
+			const [job] = this.jobs.splice(index, 1);
+			if (!job) break;
+			this.activeCount += 1;
+			this.activeAgents.add(job.agentId);
+			this.handler(job).catch((error) => {
+				this.onError(error, job);
+			}).finally(() => {
+				this.activeCount -= 1;
+				this.activeAgents.delete(job.agentId);
+				this.resolveIdleIfNeeded();
+				this.schedule();
+			});
+		}
+		this.resolveIdleIfNeeded();
+	}
+	isIdle() {
+		return this.jobs.length === 0 && this.activeCount === 0;
+	}
+	resolveIdleIfNeeded() {
+		if (!this.isIdle()) return;
+		for (const resolve of this.idleResolvers) resolve();
+		this.idleResolvers.clear();
+	}
+};
+//#endregion
+//#region ../core/src/skills.ts
+function createInMemorySkillCatalog(skills) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const skill of skills) byId.set(skill.id, cloneSkillPackage(skill));
+	return {
+		async getSkill(id) {
+			const skill = byId.get(id);
+			return skill ? cloneSkillPackage(skill) : null;
+		},
+		async listSkills() {
+			return Array.from(byId.values()).sort((a, b) => a.id.localeCompare(b.id)).map(cloneSkillPackage);
+		}
+	};
+}
+function cloneSkillPackage(skill) {
+	return {
+		...skill,
+		source: { ...skill.source },
+		references: skill.references.map((ref) => ({
+			...ref,
+			metadata: { ...ref.metadata }
+		})),
+		assets: skill.assets.map((ref) => ({
+			...ref,
+			metadata: { ...ref.metadata }
+		})),
+		templates: skill.templates.map((ref) => ({
+			...ref,
+			metadata: { ...ref.metadata }
+		})),
+		metadata: { ...skill.metadata },
+		loadedAt: new Date(skill.loadedAt)
+	};
+}
+//#endregion
+//#region ../core/src/stores.ts
+var InMemoryHephStore = class {
+	state = this;
+	messages = this;
+	inbox = this;
+	events = this;
+	memory = this;
+	mcpBindings = this;
+	skillBindings = this;
+	approvals = this;
+	deferredToolOperations = this;
+	agentSessions = /* @__PURE__ */ new Map();
+	runs = /* @__PURE__ */ new Map();
+	messageList = [];
+	inboxList = [];
+	inboxEvents = /* @__PURE__ */ new Map();
+	eventList = [];
+	eventSeqByRun = /* @__PURE__ */ new Map();
+	memoryItems = /* @__PURE__ */ new Map();
+	mcpBindingList = [];
+	mcpBindingsById = /* @__PURE__ */ new Map();
+	skillBindingList = [];
+	skillBindingsById = /* @__PURE__ */ new Map();
+	approvalRequests = /* @__PURE__ */ new Map();
+	deferredOperations = /* @__PURE__ */ new Map();
+	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.agentSessions.set(agent.id, cloneAgentSession(agent));
+		return cloneAgentSession(agent);
+	}
+	async getAgentSession(id) {
+		const agent = this.agentSessions.get(id);
+		return agent ? cloneAgentSession(agent) : null;
+	}
+	async updateAgentSession(id, patch) {
+		const existing = this.agentSessions.get(id);
+		if (!existing) throw notFound("AgentSession not found", { agentId: id });
+		const updated = {
+			...existing,
+			...patch,
+			id,
+			createdAt: existing.createdAt,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		this.agentSessions.set(id, cloneAgentSession(updated));
+		return cloneAgentSession(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.runs.set(run.id, cloneRun(run));
+		return cloneRun(run);
+	}
+	async getRun(id) {
+		const run = this.runs.get(id);
+		return run ? cloneRun(run) : null;
+	}
+	async updateRun(id, patch) {
+		const existing = this.runs.get(id);
+		if (!existing) throw notFound("Run not found", { runId: id });
+		const updated = {
+			...existing,
+			...patch,
+			id,
+			createdAt: existing.createdAt,
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+		this.runs.set(id, cloneRun(updated));
+		return cloneRun(updated);
+	}
+	async listRunsByAgent(agentId) {
+		return Array.from(this.runs.values()).filter((run) => run.agentId === agentId).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).map(cloneRun);
+	}
+	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.messageList.push(cloneMessage(message));
+		return cloneMessage(message);
+	}
+	async listMessages(agentId, options = {}) {
+		const messages = this.messageList.filter((message) => message.agentId === agentId).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+		return (options.limit === void 0 ? messages : messages.slice(Math.max(0, messages.length - options.limit))).map(cloneMessage);
+	}
+	async appendInboxEvent(input) {
+		const now = /* @__PURE__ */ new Date();
+		const event = {
+			id: input.id ?? createInboxEventId(),
+			agentId: input.agentId,
+			type: input.input.type,
+			input: clonePlain(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.inboxList.push(cloneInboxEvent(event));
+		this.inboxEvents.set(event.id, cloneInboxEvent(event));
+		return cloneInboxEvent(event);
+	}
+	async getInboxEvent(id) {
+		const event = this.inboxEvents.get(id);
+		return event ? cloneInboxEvent(event) : null;
+	}
+	async listInboxEvents(agentId, options = {}) {
+		const events = this.inboxList.filter((event) => event.agentId === agentId).filter((event) => options.status === void 0 || event.status === options.status).filter((event) => options.types === void 0 || options.types.includes(event.type)).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+		return (options.limit === void 0 ? events : events.slice(0, options.limit)).map(cloneInboxEvent);
+	}
+	async claimPendingInboxEvents(agentId, options = {}) {
+		const now = /* @__PURE__ */ new Date();
+		const pending = this.inboxList.filter((event) => event.agentId === agentId && event.status === "pending").filter((event) => options.types === void 0 || options.types.includes(event.type)).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+		return (options.limit === void 0 ? pending : pending.slice(0, options.limit)).map((event) => {
+			return cloneInboxEvent(this.replaceInboxEvent({
+				...event,
+				status: "processing",
+				claimedAt: now,
+				updatedAt: now
+			}));
+		});
+	}
+	async markInboxEventsProcessed(ids, runId) {
+		const now = /* @__PURE__ */ new Date();
+		return ids.map((id) => cloneInboxEvent(this.replaceInboxEvent({
+			...this.getInboxEventOrThrow(id),
+			status: "processed",
+			runId,
+			processedAt: now,
+			updatedAt: now,
+			error: null
+		})));
+	}
+	async markInboxEventsFailed(ids, error) {
+		const now = /* @__PURE__ */ new Date();
+		return ids.map((id) => cloneInboxEvent(this.replaceInboxEvent({
+			...this.getInboxEventOrThrow(id),
+			status: "failed",
+			failedAt: now,
+			updatedAt: now,
+			error
+		})));
+	}
+	async appendRunEvent(input) {
+		const seq = (this.eventSeqByRun.get(input.runId) ?? 0) + 1;
+		this.eventSeqByRun.set(input.runId, seq);
+		const event = {
+			id: input.id ?? createRunEventId(),
+			runId: input.runId,
+			seq,
+			type: input.type,
+			payload: input.payload ?? {},
+			sourceRefs: input.sourceRefs ?? [],
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		this.eventList.push(cloneRunEvent(event));
+		return cloneRunEvent(event);
+	}
+	async listRunEvents(runId, options = {}) {
+		const after = options.after ?? 0;
+		const events = this.eventList.filter((event) => event.runId === runId && event.seq > after).sort((a, b) => a.seq - b.seq);
+		return (options.limit === void 0 ? events : events.slice(0, options.limit)).map(cloneRunEvent);
+	}
+	async putMemory(input) {
+		const now = /* @__PURE__ */ new Date();
+		const existing = input.id ? this.memoryItems.get(input.id) : void 0;
+		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?.createdAt ?? now,
+			updatedAt: now
+		};
+		this.memoryItems.set(item.id, cloneMemoryItem(item));
+		return cloneMemoryItem(item);
+	}
+	async searchMemory(input) {
+		const now = Date.now();
+		const query = input.query?.trim().toLowerCase();
+		const topK = input.topK ?? 8;
+		const scopes = input.scopes ?? [];
+		return Array.from(this.memoryItems.values()).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 }) => cloneMemoryItem(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.mcpBindingList.push(cloneMcpBinding(binding));
+		this.mcpBindingsById.set(binding.id, cloneMcpBinding(binding));
+		return cloneMcpBinding(binding);
+	}
+	async getMcpBinding(id) {
+		const binding = this.mcpBindingsById.get(id);
+		return binding ? cloneMcpBinding(binding) : null;
+	}
+	async listMcpBindings(agentId, options = {}) {
+		const status = options.status ?? "active";
+		return this.mcpBindingList.filter((binding) => binding.agentId === agentId).filter((binding) => status === "all" || binding.status === status).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).map(cloneMcpBinding);
+	}
+	async removeMcpBinding(id) {
+		const existing = this.mcpBindingsById.get(id);
+		if (!existing) throw notFound("McpBinding not found", { bindingId: id });
+		const now = /* @__PURE__ */ new Date();
+		const updated = {
+			...existing,
+			status: "removed",
+			updatedAt: now,
+			removedAt: existing.removedAt ?? now
+		};
+		this.replaceMcpBinding(updated);
+		return cloneMcpBinding(updated);
+	}
+	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: { ...input.source },
+			allowReferences: input.allowReferences === void 0 ? [] : clonePlain(input.allowReferences),
+			status: "active",
+			metadata: input.metadata ?? {},
+			createdAt: now,
+			updatedAt: now,
+			removedAt: null
+		};
+		this.skillBindingList.push(cloneSkillBinding(binding));
+		this.skillBindingsById.set(binding.id, cloneSkillBinding(binding));
+		return cloneSkillBinding(binding);
+	}
+	async getSkillBinding(id) {
+		const binding = this.skillBindingsById.get(id);
+		return binding ? cloneSkillBinding(binding) : null;
+	}
+	async listSkillBindings(agentId, options = {}) {
+		const status = options.status ?? "active";
+		return this.skillBindingList.filter((binding) => binding.agentId === agentId).filter((binding) => status === "all" || binding.status === status).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).map(cloneSkillBinding);
+	}
+	async removeSkillBinding(id) {
+		const existing = this.skillBindingsById.get(id);
+		if (!existing) throw notFound("SkillBinding not found", { bindingId: id });
+		const now = /* @__PURE__ */ new Date();
+		const updated = {
+			...existing,
+			status: "removed",
+			updatedAt: now,
+			removedAt: existing.removedAt ?? now
+		};
+		this.replaceSkillBinding(updated);
+		return cloneSkillBinding(updated);
+	}
+	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.approvalRequests.set(request.id, cloneApprovalRequest(request));
+		return cloneApprovalRequest(request);
+	}
+	async getApprovalRequest(id) {
+		const request = this.approvalRequests.get(id);
+		return request ? cloneApprovalRequest(request) : null;
+	}
+	async listApprovalRequests(runId, options = {}) {
+		const status = options.status ?? "all";
+		return Array.from(this.approvalRequests.values()).filter((request) => request.runId === runId).filter((request) => status === "all" || request.status === status).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).map(cloneApprovalRequest);
+	}
+	async decideApprovalRequest(input) {
+		const existing = this.approvalRequests.get(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.approvalRequests.set(input.id, cloneApprovalRequest(updated));
+		return cloneApprovalRequest(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.deferredOperations.set(operation.id, cloneDeferredToolOperation(operation));
+		return cloneDeferredToolOperation(operation);
+	}
+	async getDeferredToolOperation(id) {
+		const operation = this.deferredOperations.get(id);
+		return operation ? cloneDeferredToolOperation(operation) : null;
+	}
+	async completeDeferredToolOperation(input) {
+		const existing = this.deferredOperations.get(input.id);
+		if (!existing) throw notFound("DeferredToolOperation not found", { operationId: input.id });
+		if (existing.status !== "pending") return cloneDeferredToolOperation(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.deferredOperations.set(updated.id, cloneDeferredToolOperation(updated));
+		return cloneDeferredToolOperation(updated);
+	}
+	replaceInboxEvent(updated) {
+		const index = this.inboxList.findIndex((event) => event.id === updated.id);
+		if (index === -1) throw notFound("InboxEvent not found", { inboxEventId: updated.id });
+		this.inboxList[index] = cloneInboxEvent(updated);
+		this.inboxEvents.set(updated.id, cloneInboxEvent(updated));
+		return cloneInboxEvent(updated);
+	}
+	getInboxEventOrThrow(id) {
+		const event = this.inboxEvents.get(id);
+		if (!event) throw notFound("InboxEvent not found", { inboxEventId: id });
+		return cloneInboxEvent(event);
+	}
+	replaceMcpBinding(updated) {
+		const index = this.mcpBindingList.findIndex((binding) => binding.id === updated.id);
+		if (index === -1) throw notFound("McpBinding not found", { bindingId: updated.id });
+		this.mcpBindingList[index] = cloneMcpBinding(updated);
+		this.mcpBindingsById.set(updated.id, cloneMcpBinding(updated));
+		return cloneMcpBinding(updated);
+	}
+	replaceSkillBinding(updated) {
+		const index = this.skillBindingList.findIndex((binding) => binding.id === updated.id);
+		if (index === -1) throw notFound("SkillBinding not found", { bindingId: updated.id });
+		this.skillBindingList[index] = cloneSkillBinding(updated);
+		this.skillBindingsById.set(updated.id, cloneSkillBinding(updated));
+		return cloneSkillBinding(updated);
+	}
+};
+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 cloneAgentSession(agent) {
+	return {
+		...agent,
+		state: { ...agent.state },
+		metadata: { ...agent.metadata },
+		auth: agent.auth ? { ...agent.auth } : null,
+		createdAt: new Date(agent.createdAt),
+		updatedAt: new Date(agent.updatedAt)
+	};
+}
+function cloneRun(run) {
+	return {
+		...run,
+		input: clonePlain(run.input),
+		auth: run.auth ? { ...run.auth } : null,
+		contextManifest: run.contextManifest ? clonePlain(run.contextManifest) : null,
+		skillManifest: run.skillManifest ? clonePlain(run.skillManifest) : null,
+		toolManifest: run.toolManifest ? clonePlain(run.toolManifest) : null,
+		error: run.error ? clonePlain(run.error) : null,
+		metadata: { ...run.metadata },
+		queuedAt: new Date(run.queuedAt),
+		startedAt: run.startedAt ? new Date(run.startedAt) : null,
+		completedAt: run.completedAt ? new Date(run.completedAt) : null,
+		createdAt: new Date(run.createdAt),
+		updatedAt: new Date(run.updatedAt)
+	};
+}
+function cloneMessage(message) {
+	return {
+		...message,
+		auth: message.auth ? { ...message.auth } : null,
+		metadata: { ...message.metadata },
+		createdAt: new Date(message.createdAt)
+	};
+}
+function cloneInboxEvent(event) {
+	return {
+		...event,
+		input: clonePlain(event.input),
+		auth: event.auth ? { ...event.auth } : null,
+		metadata: { ...event.metadata },
+		createdAt: new Date(event.createdAt),
+		updatedAt: new Date(event.updatedAt),
+		claimedAt: event.claimedAt ? new Date(event.claimedAt) : null,
+		processedAt: event.processedAt ? new Date(event.processedAt) : null,
+		failedAt: event.failedAt ? new Date(event.failedAt) : null,
+		error: event.error ? clonePlain(event.error) : null
+	};
+}
+function cloneRunEvent(event) {
+	return {
+		...event,
+		payload: clonePlain(event.payload),
+		sourceRefs: event.sourceRefs.map((ref) => ({ ...ref })),
+		createdAt: new Date(event.createdAt)
+	};
+}
+function cloneMemoryItem(item) {
+	return {
+		...item,
+		scope: { ...item.scope },
+		sourceRefs: item.sourceRefs.map((ref) => ({ ...ref })),
+		expiresAt: item.expiresAt ? new Date(item.expiresAt) : null,
+		createdAt: new Date(item.createdAt),
+		updatedAt: new Date(item.updatedAt)
+	};
+}
+function cloneMcpBinding(binding) {
+	return {
+		...binding,
+		allowTools: clonePlain(binding.allowTools),
+		metadata: { ...binding.metadata },
+		createdAt: new Date(binding.createdAt),
+		updatedAt: new Date(binding.updatedAt),
+		removedAt: binding.removedAt ? new Date(binding.removedAt) : null
+	};
+}
+function cloneSkillBinding(binding) {
+	return {
+		...binding,
+		source: { ...binding.source },
+		allowReferences: clonePlain(binding.allowReferences),
+		metadata: { ...binding.metadata },
+		createdAt: new Date(binding.createdAt),
+		updatedAt: new Date(binding.updatedAt),
+		removedAt: binding.removedAt ? new Date(binding.removedAt) : null
+	};
+}
+function cloneApprovalRequest(request) {
+	return {
+		...request,
+		input: clonePlain(request.input),
+		requestedBy: request.requestedBy ? { ...request.requestedBy } : null,
+		decidedBy: request.decidedBy ? { ...request.decidedBy } : null,
+		metadata: { ...request.metadata },
+		createdAt: new Date(request.createdAt),
+		updatedAt: new Date(request.updatedAt),
+		decidedAt: request.decidedAt ? new Date(request.decidedAt) : null
+	};
+}
+function cloneDeferredToolOperation(operation) {
+	return {
+		...operation,
+		auth: operation.auth ? { ...operation.auth } : null,
+		result: clonePlain(operation.result),
+		error: operation.error ? clonePlain(operation.error) : null,
+		metadata: { ...operation.metadata },
+		createdAt: new Date(operation.createdAt),
+		updatedAt: new Date(operation.updatedAt),
+		completedAt: operation.completedAt ? new Date(operation.completedAt) : null
+	};
+}
+function clonePlain(value) {
+	return structuredClone(value);
+}
+//#endregion
+//#region ../core/src/runtime.ts
+var StreamableHttpMcpToolExecutor = class {
+	async callTool(ctx) {
+		const credentials = await ctx.resolved.resolveCredentials?.({
+			auth: ctx.auth,
+			agent: ctx.agent,
+			run: ctx.run,
+			binding: ctx.binding,
+			app: ctx.app
+		});
+		const headers = new Headers({
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream"
+		});
+		for (const [key, value] of Object.entries(credentials?.headers ?? {})) headers.set(key, value);
+		const rpcId = globalThis.crypto?.randomUUID?.() ?? `${Date.now()}_${Math.random()}`;
+		const requestInit = {
+			method: "POST",
+			headers,
+			body: JSON.stringify({
+				jsonrpc: "2.0",
+				id: rpcId,
+				method: "tools/call",
+				params: {
+					name: ctx.manifestTool.remoteToolName,
+					arguments: ctx.input ?? {}
+				}
+			})
+		};
+		if (ctx.signal !== void 0) requestInit.signal = ctx.signal;
+		const response = await fetch(ctx.resolved.endpoint, requestInit);
+		const rawBody = await response.text();
+		const parsed = parseMcpResponseBody(rawBody, response.headers.get("Content-Type"));
+		if (!response.ok) throw new HephError({
+			code: "HEPH7002",
+			title: "MCP tool call failed",
+			message: `MCP server returned HTTP ${response.status}.`,
+			status: 503,
+			details: {
+				toolId: ctx.manifestTool.id,
+				bindingId: ctx.binding.id,
+				status: response.status,
+				body: parsed ?? rawBody
+			}
+		});
+		if (isJsonRpcError(parsed)) throw new HephError({
+			code: "HEPH7002",
+			title: "MCP tool call failed",
+			message: "MCP server returned a JSON-RPC error.",
+			status: 503,
+			details: {
+				toolId: ctx.manifestTool.id,
+				bindingId: ctx.binding.id,
+				error: parsed.error
+			}
+		});
+		if (isRecord(parsed) && "result" in parsed) return parsed.result;
+		return parsed;
+	}
+};
+function createHeph(options) {
+	const stores = options.stores ?? new InMemoryHephStore();
+	const queue = options.queue ?? new InProcessQueue({ concurrency: options.execution?.concurrency ?? 4 });
+	const executor = options.executor ?? new MinimalRunExecutor();
+	const resolver = normalizeAgentSpecResolver(options.agents);
+	const mcpResolver = options.mcp?.resolver ?? null;
+	const mcpToolExecutor = options.mcp?.toolExecutor ?? new StreamableHttpMcpToolExecutor();
+	const skillCatalog = options.skills?.catalog ?? createInMemorySkillCatalog([]);
+	const renderer = new ContextRenderer();
+	const app = options.app ?? {};
+	const abortControllers = /* @__PURE__ */ new Map();
+	const executionMode = options.execution?.mode ?? "single-process";
+	const reducerOptions = {
+		maxEventsPerRun: normalizeMaxEventsPerRun(options.inbox?.maxEventsPerRun),
+		textSeparator: options.inbox?.textSeparator ?? "\n\n--- next message ---\n\n"
+	};
+	let consumerStarted = false;
+	const runtime = {
+		stores,
+		queue,
+		agents: {
+			async create(input) {
+				const spec = await resolveSpecOrThrow(resolver, input.spec, input.auth ?? null);
+				const skillPackages = await resolveSkillPackagesForSession(spec, input.skills ?? []);
+				const agent = await stores.state.createAgentSession({
+					agentSpecId: spec.id,
+					agentSpecVersion: spec.version,
+					state: input.state,
+					auth: input.auth ?? null,
+					metadata: input.metadata
+				});
+				for (const skillPackage of skillPackages) await stores.skillBindings.createSkillBinding({
+					agentId: agent.id,
+					skillId: skillPackage.id,
+					name: skillPackage.name,
+					version: skillPackage.version,
+					source: skillPackage.source,
+					allowReferences: [],
+					metadata: { description: skillPackage.description }
+				});
+				return agent;
+			},
+			async createAndRun(input) {
+				const agent = await runtime.agents.create(input);
+				const runInput = normalizeRunInput(input.input);
+				const appended = await appendRunInputToInbox({
+					agentId: agent.id,
+					input: runInput,
+					auth: input.auth ?? null,
+					metadata: input.metadata,
+					messageMetadata: {
+						...input.metadata ?? {},
+						runInput: true
+					}
+				});
+				const run = await scheduleAgent(agent.id);
+				if (!run) throw new HephError({
+					code: "HEPH4002",
+					title: "Run was not scheduled",
+					message: `AgentSession ${agent.id} did not produce a Run from its initial input.`,
+					status: 409,
+					details: {
+						agentId: agent.id,
+						inboxEventId: appended.inboxEvent.id
+					}
+				});
+				return {
+					agent,
+					run,
+					message: appended.message,
+					inboxEvent: appended.inboxEvent,
+					agent_id: agent.id,
+					agent_spec_id: agent.agentSpecId,
+					run_id: run.id
+				};
+			},
+			async appendMessage(input) {
+				await getAgentOrThrow(stores, input.agentId);
+				const appended = await appendRunInputToInbox({
+					agentId: input.agentId,
+					input: {
+						type: input.type ?? "user.message",
+						text: input.content
+					},
+					auth: input.auth ?? null,
+					metadata: input.metadata,
+					messageMetadata: input.metadata
+				});
+				const shouldSchedule = input.schedule ?? true;
+				if (!appended.message) throw new HephError({
+					code: "HEPH4004",
+					title: "Message was not stored",
+					message: "The user message input did not produce a MessageStore record.",
+					status: 500,
+					details: {
+						agentId: input.agentId,
+						inboxEventId: appended.inboxEvent.id
+					}
+				});
+				const inboxEvent = shouldSchedule ? await scheduleAfterAppend(input.agentId, appended.inboxEvent) : appended.inboxEvent;
+				return {
+					message: appended.message,
+					inboxEvent,
+					message_id: appended.message.id,
+					inbox_event_id: inboxEvent.id,
+					scheduled: shouldSchedule
+				};
+			},
+			schedule(agentId) {
+				return scheduleAgent(agentId);
+			},
+			get(agentId) {
+				return stores.state.getAgentSession(agentId);
+			},
+			async addMcpBinding(input) {
+				const agent = await getAgentOrThrow(stores, input.agentId);
+				const spec = await resolveSpecOrThrow(resolver, agent.agentSpecId, input.auth ?? agent.auth);
+				const bindingId = createMcpBindingId();
+				const now = /* @__PURE__ */ new Date();
+				const draft = {
+					id: bindingId,
+					agentId: agent.id,
+					capabilityId: input.capabilityId,
+					accountRef: input.accountRef ?? null,
+					allowTools: Array.isArray(input.allowTools) ? [...input.allowTools] : input.allowTools,
+					status: "active",
+					metadata: input.metadata ?? {},
+					createdAt: now,
+					updatedAt: now,
+					removedAt: null
+				};
+				enforceMcpPolicy(spec, draft);
+				validateMcpCatalog(draft, await resolveMcpBindingOrThrow({
+					resolver: mcpResolver,
+					auth: input.auth ?? agent.auth,
+					agent,
+					binding: draft,
+					app
+				}));
+				return stores.mcpBindings.createMcpBinding({
+					id: bindingId,
+					agentId: agent.id,
+					capabilityId: input.capabilityId,
+					accountRef: input.accountRef ?? null,
+					allowTools: Array.isArray(input.allowTools) ? [...input.allowTools] : input.allowTools,
+					metadata: input.metadata
+				});
+			},
+			async listMcpBindings(agentId) {
+				await getAgentOrThrow(stores, agentId);
+				return stores.mcpBindings.listMcpBindings(agentId);
+			},
+			async removeMcpBinding(input) {
+				const agent = await getAgentOrThrow(stores, input.agentId);
+				const binding = await stores.mcpBindings.getMcpBinding(input.bindingId);
+				if (!binding || binding.agentId !== agent.id) throw new HephError({
+					code: "HEPH5001",
+					title: "McpBinding not found",
+					message: `McpBinding ${input.bindingId} was not found.`,
+					status: 404,
+					details: {
+						agentId: input.agentId,
+						bindingId: input.bindingId
+					}
+				});
+				return stores.mcpBindings.removeMcpBinding(input.bindingId);
+			}
+		},
+		runs: {
+			async create(input) {
+				const agent = await getAgentOrThrow(stores, input.agentId);
+				return createRunForAgent({
+					agent,
+					input: normalizeRunInput(input.input),
+					auth: input.auth ?? agent.auth,
+					metadata: input.metadata,
+					enqueue: input.enqueue ?? true
+				});
+			},
+			get(runId) {
+				return stores.state.getRun(runId);
+			},
+			async cancel(runId) {
+				return cancelRun(runId);
+			}
+		},
+		messages: {
+			append(input) {
+				return stores.messages.appendMessage({
+					agentId: input.agentId,
+					role: input.role,
+					content: input.content,
+					auth: input.auth ?? null,
+					metadata: input.metadata
+				});
+			},
+			list(agentId, listOptions) {
+				return stores.messages.listMessages(agentId, listOptions);
+			}
+		},
+		approvals: {
+			get(approvalRequestId) {
+				return stores.approvals.getApprovalRequest(approvalRequestId);
+			},
+			list(runId) {
+				return stores.approvals.listApprovalRequests(runId);
+			},
+			async decide(input) {
+				const request = await stores.approvals.decideApprovalRequest({
+					id: input.approvalRequestId,
+					decision: input.decision,
+					decidedBy: input.auth ?? null,
+					metadata: input.metadata
+				});
+				await stores.events.appendRunEvent({
+					runId: request.runId,
+					type: input.decision === "granted" ? "approval.granted" : "approval.rejected",
+					payload: {
+						approvalRequestId: request.id,
+						toolId: request.toolId
+					},
+					sourceRefs: [{
+						type: "approval_request",
+						id: request.id
+					}]
+				});
+				return request;
+			}
+		},
+		tools: {
+			call(runId, input) {
+				return callTool(runId, input);
+			},
+			tryCall(runId, input) {
+				return tryCallTool(runId, input);
+			}
+		},
+		operations: {
+			deferToolResult(input) {
+				return deferToolResult(input);
+			},
+			get(operationId) {
+				return stores.deferredToolOperations.getDeferredToolOperation(operationId);
+			},
+			complete(input) {
+				return completeDeferredToolResult(input);
+			}
+		},
+		renderRunContext(runId) {
+			return renderRunContext(runId);
+		},
+		handleJob(job) {
+			return handleJob(job);
+		},
+		async startWorker() {
+			if (consumerStarted) return;
+			if (!queue.startConsumer) throw new HephError({
+				code: "HEPH4003",
+				title: "Queue consumer is not available",
+				message: "This QueueAdapter does not expose startConsumer(). Use handleJob() or an adapter-specific batch handler.",
+				status: 422
+			});
+			consumerStarted = true;
+			await queue.startConsumer((job) => handleJob(job));
+		},
+		async drain() {
+			await queue.onIdle?.();
+		}
+	};
+	if (options.execution?.autoStartConsumer ?? executionMode === "single-process") runtime.startWorker();
+	return runtime;
+	async function handleJob(job) {
+		switch (job.type) {
+			case "schedule_agent":
+				await scheduleAgent(job.agentId);
+				return;
+			case "execute_run":
+			case "resume_run":
+				await executeRun(job.runId);
+				return;
+			case "cancel_run":
+				await cancelRun(job.runId);
+				return;
+			case "ingest_memory": return;
+		}
+	}
+	async function appendRunInputToInbox(input) {
+		const normalized = normalizeRunInput(input.input);
+		const message = "text" in normalized ? await stores.messages.appendMessage({
+			agentId: input.agentId,
+			role: "user",
+			content: normalized.text,
+			auth: input.auth,
+			metadata: input.messageMetadata
+		}) : null;
+		const runInput = message ? addMessageIdToRunInput(normalized, message.id) : normalized;
+		return {
+			runInput,
+			message,
+			inboxEvent: await stores.inbox.appendInboxEvent({
+				agentId: input.agentId,
+				input: runInput,
+				auth: input.auth,
+				metadata: input.metadata
+			})
+		};
+	}
+	async function scheduleAfterAppend(agentId, inboxEvent) {
+		if (inboxEvent.type === "steering.message") {
+			await scheduleAgent(agentId);
+			return await stores.inbox.getInboxEvent(inboxEvent.id) ?? inboxEvent;
+		}
+		await queue.enqueue({
+			type: "schedule_agent",
+			agentId
+		});
+		return inboxEvent;
+	}
+	async function scheduleAgent(agentId) {
+		let agent = await getAgentOrThrow(stores, agentId);
+		if (agent.activeRunId) {
+			const activeRun = await stores.state.getRun(agent.activeRunId);
+			if (activeRun && !isTerminalRun(activeRun)) {
+				await processPendingCancellationEvents(agent, activeRun);
+				await processPendingSteeringEvents(agent, activeRun);
+				return null;
+			}
+			agent = await stores.state.updateAgentSession(agent.id, { activeRunId: null });
+		}
+		const nextPending = await stores.inbox.listInboxEvents(agent.id, {
+			status: "pending",
+			limit: 1
+		});
+		if (nextPending.length === 0) return null;
+		const claimOptions = { types: [nextPending[0].type] };
+		if (reducerOptions.maxEventsPerRun !== void 0) claimOptions.limit = reducerOptions.maxEventsPerRun;
+		const claimed = await stores.inbox.claimPendingInboxEvents(agent.id, claimOptions);
+		if (claimed.length === 0) return null;
+		try {
+			const inboxEventIds = claimed.map((event) => event.id);
+			const run = await createRunForAgent({
+				agent,
+				input: reduceInboxEvents(claimed, reducerOptions.textSeparator),
+				auth: firstAuth(claimed) ?? agent.auth,
+				metadata: {
+					inboxEventIds,
+					inboxEventCount: claimed.length
+				},
+				sourceRefs: toInboxSourceRefs(claimed),
+				enqueue: false
+			});
+			await stores.inbox.markInboxEventsProcessed(inboxEventIds, run.id);
+			await queue.enqueue({
+				type: "execute_run",
+				agentId: agent.id,
+				runId: run.id
+			});
+			return run;
+		} catch (error) {
+			await stores.inbox.markInboxEventsFailed(claimed.map((event) => event.id), toRunError(error));
+			throw error;
+		}
+	}
+	async function processPendingCancellationEvents(agent, activeRun) {
+		const cancellationEvents = await stores.inbox.claimPendingInboxEvents(agent.id, { types: ["run.cancel_requested"] });
+		if (cancellationEvents.length === 0) return;
+		const cancelled = await cancelRun(activeRun.id, { sourceRefs: toInboxSourceRefs(cancellationEvents) });
+		await stores.inbox.markInboxEventsProcessed(cancellationEvents.map((event) => event.id), cancelled.id);
+	}
+	async function processPendingSteeringEvents(agent, activeRun) {
+		const steeringEvents = await stores.inbox.claimPendingInboxEvents(agent.id, { types: ["steering.message"] });
+		for (const event of steeringEvents) await stores.events.appendRunEvent({
+			runId: activeRun.id,
+			type: "run.steering_received",
+			payload: {
+				agentId: agent.id,
+				inboxEventId: event.id,
+				input: event.input
+			},
+			sourceRefs: toInboxSourceRefs([event])
+		});
+		if (steeringEvents.length > 0) await stores.inbox.markInboxEventsProcessed(steeringEvents.map((event) => event.id), activeRun.id);
+	}
+	async function createRunForAgent(input) {
+		const spec = await resolveSpecOrThrow(resolver, input.agent.agentSpecId, input.auth ?? input.agent.auth);
+		const run = await stores.state.createRun({
+			agentId: input.agent.id,
+			agentSpecId: spec.id,
+			agentSpecVersion: spec.version,
+			status: "queued",
+			input: input.input,
+			auth: input.auth,
+			metadata: input.metadata
+		});
+		await stores.state.updateAgentSession(input.agent.id, { activeRunId: run.id });
+		await stores.events.appendRunEvent({
+			runId: run.id,
+			type: "run.queued",
+			payload: {
+				agentId: input.agent.id,
+				agentSpecId: spec.id
+			},
+			sourceRefs: input.sourceRefs
+		});
+		if (input.enqueue) await queue.enqueue({
+			type: "execute_run",
+			agentId: input.agent.id,
+			runId: run.id
+		});
+		return run;
+	}
+	async function cancelRun(runId, options = {}) {
+		const run = await getRunOrThrow(stores, runId);
+		if (isTerminalRun(run)) return run;
+		abortControllers.get(run.id)?.abort();
+		await stores.events.appendRunEvent({
+			runId: run.id,
+			type: "run.cancel_requested",
+			payload: {},
+			sourceRefs: options.sourceRefs
+		});
+		const cancelled = await stores.state.updateRun(run.id, {
+			status: "cancelled",
+			completedAt: /* @__PURE__ */ new Date()
+		});
+		await stores.events.appendRunEvent({
+			runId: run.id,
+			type: "run.cancelled",
+			payload: {}
+		});
+		const agent = await stores.state.getAgentSession(run.agentId);
+		if (agent?.activeRunId === run.id) await stores.state.updateAgentSession(agent.id, { activeRunId: null });
+		await enqueueScheduleIfPending(run.agentId);
+		return cancelled;
+	}
+	async function executeRun(runId) {
+		const initialRun = await getRunOrThrow(stores, runId);
+		if (isTerminalRun(initialRun)) return;
+		const agent = await getAgentOrThrow(stores, initialRun.agentId);
+		const spec = await resolveSpecOrThrow(resolver, initialRun.agentSpecId, initialRun.auth ?? agent.auth);
+		const controller = new AbortController();
+		abortControllers.set(initialRun.id, controller);
+		try {
+			const skillManifest = await createSkillManifestForRun(agent, initialRun);
+			const runWithSkillManifest = await stores.state.updateRun(initialRun.id, { skillManifest });
+			await stores.events.appendRunEvent({
+				runId: runWithSkillManifest.id,
+				type: "skill_manifest.created",
+				payload: { skillCount: skillManifest.skills.length },
+				sourceRefs: skillManifest.skills.map((skill) => ({
+					type: "skill_binding",
+					id: skill.bindingId
+				}))
+			});
+			const toolManifest = await createToolManifestForRun(agent, spec, runWithSkillManifest);
+			const runWithToolManifest = await stores.state.updateRun(runWithSkillManifest.id, { toolManifest });
+			await stores.events.appendRunEvent({
+				runId: runWithToolManifest.id,
+				type: "tool_manifest.created",
+				payload: {
+					toolCount: toolManifest.tools.length,
+					localToolCount: toolManifest.tools.filter((tool) => tool.source === "local").length,
+					mcpToolCount: toolManifest.tools.filter((tool) => tool.source === "mcp").length
+				},
+				sourceRefs: toolManifest.tools.flatMap((tool) => tool.source === "mcp" ? [{
+					type: "mcp_binding",
+					id: tool.bindingId
+				}] : [])
+			});
+			const running = await stores.state.updateRun(runWithToolManifest.id, {
+				status: "running",
+				startedAt: /* @__PURE__ */ new Date()
+			});
+			await stores.events.appendRunEvent({
+				runId: running.id,
+				type: "run.started",
+				payload: {
+					agentId: agent.id,
+					agentSpecId: spec.id
+				}
+			});
+			const renderedContext = await renderRunContext(running.id);
+			const runWithContext = await stores.state.updateRun(running.id, { contextManifest: renderedContext.manifest });
+			const callToolForRun = (input) => callTool(runWithContext.id, {
+				...input,
+				auth: input.auth ?? runWithContext.auth,
+				signal: input.signal ?? controller.signal
+			});
+			const tryCallToolForRun = (input) => tryCallTool(runWithContext.id, {
+				...input,
+				auth: input.auth ?? runWithContext.auth,
+				signal: input.signal ?? controller.signal
+			});
+			await executor.execute({
+				auth: runWithContext.auth,
+				agent,
+				spec,
+				run: runWithContext,
+				renderedContext,
+				stores,
+				app,
+				signal: controller.signal,
+				emit(event) {
+					return stores.events.appendRunEvent({
+						...event,
+						runId: runWithContext.id
+					}).then(() => void 0);
+				},
+				appendMessage(message) {
+					return stores.messages.appendMessage({
+						...message,
+						agentId: agent.id,
+						auth: runWithContext.auth
+					});
+				},
+				tools: {
+					call: callToolForRun,
+					tryCall: tryCallToolForRun
+				},
+				callTool: callToolForRun,
+				tryCallTool: tryCallToolForRun,
+				deferToolResult(input) {
+					return deferToolResult({
+						...input,
+						runId: input.runId ?? runWithContext.id,
+						auth: input.auth ?? runWithContext.auth
+					});
+				}
+			});
+			const current = await getRunOrThrow(stores, running.id);
+			if (current.status === "running") {
+				await stores.state.updateRun(current.id, {
+					status: "completed",
+					completedAt: /* @__PURE__ */ new Date()
+				});
+				await stores.events.appendRunEvent({
+					runId: current.id,
+					type: "run.completed",
+					payload: {}
+				});
+				await clearActiveRunIfCurrent(agent.id, current.id);
+				await enqueueScheduleIfPending(agent.id);
+			}
+		} catch (error) {
+			if ((await stores.state.getRun(initialRun.id))?.status === "cancelled") return;
+			const runError = {
+				message: error instanceof Error ? error.message : String(error),
+				details: toErrorDetails(error)
+			};
+			if (error instanceof HephError) Object.assign(runError, { code: error.code });
+			await stores.state.updateRun(initialRun.id, {
+				status: "failed",
+				completedAt: /* @__PURE__ */ new Date(),
+				error: runError
+			});
+			await stores.events.appendRunEvent({
+				runId: initialRun.id,
+				type: "run.failed",
+				payload: toErrorDetails(error)
+			});
+			await clearActiveRunIfCurrent(agent.id, initialRun.id);
+			await enqueueScheduleIfPending(agent.id);
+		} finally {
+			abortControllers.delete(initialRun.id);
+		}
+	}
+	async function deferToolResult(input) {
+		const run = await getRunOrThrow(stores, input.runId);
+		const agent = await getAgentOrThrow(stores, run.agentId);
+		const operation = await stores.deferredToolOperations.createDeferredToolOperation({
+			agentId: agent.id,
+			runId: run.id,
+			toolId: input.toolId,
+			auth: input.auth ?? run.auth ?? agent.auth,
+			...input.operationId !== void 0 ? { id: input.operationId } : {},
+			...input.toolCallId !== void 0 ? { toolCallId: input.toolCallId } : {},
+			...input.resumePolicy !== void 0 ? { resumePolicy: input.resumePolicy } : {},
+			...input.metadata !== void 0 ? { metadata: input.metadata } : {}
+		});
+		await stores.events.appendRunEvent({
+			runId: run.id,
+			type: "tool.deferred",
+			payload: {
+				operationId: operation.id,
+				toolId: operation.toolId,
+				toolCallId: operation.toolCallId,
+				resumePolicy: operation.resumePolicy
+			},
+			sourceRefs: [{
+				type: "deferred_tool_operation",
+				id: operation.id
+			}]
+		});
+		return operation;
+	}
+	async function completeDeferredToolResult(input) {
+		if (!await stores.deferredToolOperations.getDeferredToolOperation(input.operationId)) throw new HephError({
+			code: "HEPH3005",
+			title: "DeferredToolOperation not found",
+			message: `DeferredToolOperation ${input.operationId} was not found.`,
+			status: 404,
+			details: { operationId: input.operationId }
+		});
+		const status = input.status ?? (input.error ? "failed" : "completed");
+		const operation = await stores.deferredToolOperations.completeDeferredToolOperation({
+			id: input.operationId,
+			status,
+			result: input.result,
+			error: input.error,
+			metadata: input.metadata
+		});
+		const message = await stores.messages.appendMessage({
+			agentId: operation.agentId,
+			role: "tool",
+			content: input.content ?? renderDeferredToolResultContent(operation),
+			sourceRunId: operation.runId,
+			auth: input.auth ?? operation.auth,
+			metadata: {
+				type: "tool_result",
+				deferredToolOperationId: operation.id,
+				toolId: operation.toolId,
+				toolCallId: operation.toolCallId,
+				status: operation.status,
+				...input.metadata ?? {}
+			}
+		});
+		const eventType = status === "completed" ? "deferred_tool.completed" : "deferred_tool.failed";
+		await stores.events.appendRunEvent({
+			runId: operation.runId,
+			type: eventType,
+			payload: {
+				operationId: operation.id,
+				toolId: operation.toolId,
+				toolCallId: operation.toolCallId,
+				status: operation.status,
+				messageId: message.id,
+				result: operation.result,
+				error: operation.error
+			},
+			sourceRefs: [{
+				type: "deferred_tool_operation",
+				id: operation.id
+			}, {
+				type: "message",
+				id: message.id
+			}]
+		});
+		if (!(input.schedule ?? operation.resumePolicy === "auto")) return {
+			operation,
+			message,
+			inboxEvent: null,
+			scheduled: false
+		};
+		const inboxEvent = await stores.inbox.appendInboxEvent({
+			agentId: operation.agentId,
+			input: {
+				type: "system.event",
+				payload: {
+					event: "deferred_tool.completed",
+					operationId: operation.id,
+					runId: operation.runId,
+					toolId: operation.toolId,
+					toolCallId: operation.toolCallId,
+					status: operation.status
+				},
+				messageIds: [message.id]
+			},
+			auth: input.auth ?? operation.auth,
+			metadata: {
+				deferredToolOperationId: operation.id,
+				toolId: operation.toolId,
+				status: operation.status
+			}
+		});
+		await queue.enqueue({
+			type: "schedule_agent",
+			agentId: operation.agentId
+		});
+		return {
+			operation,
+			message,
+			inboxEvent,
+			scheduled: true
+		};
+	}
+	async function enqueueScheduleIfPending(agentId) {
+		if ((await stores.inbox.listInboxEvents(agentId, {
+			status: "pending",
+			limit: 1
+		})).length > 0) await queue.enqueue({
+			type: "schedule_agent",
+			agentId
+		});
+	}
+	async function clearActiveRunIfCurrent(agentId, runId) {
+		if ((await stores.state.getAgentSession(agentId))?.activeRunId === runId) await stores.state.updateAgentSession(agentId, { activeRunId: null });
+	}
+	async function resolveSkillPackagesForSession(spec, skillIds) {
+		const uniqueSkillIds = unique(skillIds);
+		if (uniqueSkillIds.length === 0) return [];
+		const packages = [];
+		for (const skillId of uniqueSkillIds) {
+			enforceSkillPolicy(spec, skillId);
+			const skillPackage = await skillCatalog.getSkill(skillId);
+			if (!skillPackage) throw new HephError({
+				code: "HEPH8003",
+				title: "Skill not found",
+				message: `Skill ${skillId} was not found in the configured SkillCatalog.`,
+				status: 422,
+				details: {
+					agentSpecId: spec.id,
+					skillId
+				}
+			});
+			packages.push(skillPackage);
+		}
+		return packages;
+	}
+	async function createSkillManifestForRun(agent, run) {
+		const bindings = await stores.skillBindings.listSkillBindings(agent.id);
+		const skills = [];
+		for (const binding of bindings) {
+			const skillPackage = await skillCatalog.getSkill(binding.skillId);
+			if (!skillPackage) throw new HephError({
+				code: "HEPH8003",
+				title: "Skill not found",
+				message: `Skill ${binding.skillId} was not found in the configured SkillCatalog.`,
+				status: 422,
+				details: {
+					agentId: agent.id,
+					bindingId: binding.id,
+					skillId: binding.skillId
+				}
+			});
+			skills.push({
+				bindingId: binding.id,
+				skillId: binding.skillId,
+				name: skillPackage.name,
+				version: skillPackage.version,
+				description: skillPackage.description,
+				instructions: skillPackage.instructions,
+				descriptionHash: await sha256Text(skillPackage.description),
+				instructionHash: await sha256Text(skillPackage.instructions),
+				source: { ...binding.source },
+				availableReferences: filterSkillReferences(skillPackage.references, binding.allowReferences),
+				availableAssets: skillPackage.assets.map(cloneSkillResourceRef),
+				availableTemplates: skillPackage.templates.map(cloneSkillResourceRef),
+				metadata: {
+					...skillPackage.metadata,
+					...binding.metadata
+				}
+			});
+		}
+		return {
+			runId: run.id,
+			skills,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async function createToolManifestForRun(agent, spec, run) {
+		const tools = spec.tools.map(toLocalManifestTool);
+		const bindings = await stores.mcpBindings.listMcpBindings(agent.id);
+		for (const binding of bindings) {
+			enforceMcpPolicy(spec, binding);
+			const resolved = await resolveMcpBindingOrThrow({
+				resolver: mcpResolver,
+				auth: run.auth ?? agent.auth,
+				agent,
+				binding,
+				app
+			});
+			validateMcpCatalog(binding, resolved);
+			tools.push(...filterMcpCatalog(binding, resolved).map((tool) => toMcpManifestTool(binding, tool)));
+		}
+		return {
+			runId: run.id,
+			tools,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async function callTool(runId, input) {
+		const run = await getRunOrThrow(stores, runId);
+		if (run.status !== "running" && run.status !== "paused") throw new HephError({
+			code: "HEPH3004",
+			title: "Tool call is not allowed for this Run status",
+			message: `Run ${run.id} is ${run.status}; tool calls require running or paused.`,
+			status: 409,
+			details: {
+				runId: run.id,
+				status: run.status,
+				toolId: input.toolId
+			}
+		});
+		if (!run.toolManifest) throw new HephError({
+			code: "HEPH3003",
+			title: "ToolManifest is not ready",
+			message: `Run ${run.id} is ${run.status} but has no Run-scoped ToolManifest.`,
+			status: 500,
+			details: {
+				runId: run.id,
+				status: run.status,
+				toolId: input.toolId
+			}
+		});
+		const manifestTool = run.toolManifest.tools.find((tool) => tool.id === input.toolId);
+		if (!manifestTool) throw new HephError({
+			code: "HEPH3005",
+			title: "Tool is not available for this Run",
+			message: `Tool ${input.toolId} is not present in Run ${run.id}'s ToolManifest.`,
+			status: 404,
+			details: {
+				runId: run.id,
+				toolId: input.toolId
+			}
+		});
+		const agent = await getAgentOrThrow(stores, run.agentId);
+		const spec = await resolveSpecOrThrow(resolver, run.agentSpecId, input.auth ?? run.auth ?? agent.auth);
+		const auth = input.auth ?? run.auth;
+		const toolInput = input.input ?? {};
+		await ensureToolApproval({
+			run,
+			agent,
+			manifestTool,
+			input: toolInput,
+			auth,
+			approvalRequestId: input.approvalRequestId
+		});
+		await stores.events.appendRunEvent({
+			runId: run.id,
+			type: "tool.started",
+			payload: {
+				toolId: manifestTool.id,
+				displayName: manifestTool.displayName,
+				source: manifestTool.source,
+				input: toolInput
+			},
+			sourceRefs: toolSourceRefs(manifestTool, input.approvalRequestId)
+		});
+		try {
+			const result = manifestTool.source === "local" ? await callLocalTool({
+				spec,
+				manifestTool,
+				input: toolInput,
+				auth,
+				agent,
+				run,
+				signal: input.signal ?? new AbortController().signal
+			}) : await callMcpTool({
+				manifestTool,
+				input: toolInput,
+				auth,
+				agent,
+				run,
+				signal: input.signal
+			});
+			await stores.events.appendRunEvent({
+				runId: run.id,
+				type: "tool.completed",
+				payload: {
+					toolId: manifestTool.id,
+					source: manifestTool.source,
+					result
+				},
+				sourceRefs: toolSourceRefs(manifestTool, input.approvalRequestId)
+			});
+			return {
+				toolId: manifestTool.id,
+				result,
+				ok: true
+			};
+		} catch (error) {
+			await stores.events.appendRunEvent({
+				runId: run.id,
+				type: "tool.failed",
+				payload: {
+					toolId: manifestTool.id,
+					source: manifestTool.source,
+					error: toErrorDetails(error)
+				},
+				sourceRefs: toolSourceRefs(manifestTool, input.approvalRequestId)
+			});
+			throw error;
+		}
+	}
+	async function tryCallTool(runId, input) {
+		try {
+			return {
+				...await callTool(runId, input),
+				ok: true
+			};
+		} catch (error) {
+			if (shouldRethrowToolCallAttemptError(error)) throw error;
+			return {
+				toolId: input.toolId,
+				ok: false,
+				error: toRunError(error)
+			};
+		}
+	}
+	async function ensureToolApproval(input) {
+		if (!(input.manifestTool.requiresApproval || input.manifestTool.sideEffect !== false)) return;
+		if (input.approvalRequestId) {
+			const request = await stores.approvals.getApprovalRequest(input.approvalRequestId);
+			if (request && request.runId === input.run.id && request.toolId === input.manifestTool.id && request.status === "granted") return;
+			throw new HephError({
+				code: "HEPH3002",
+				title: "Approval required",
+				message: `Tool ${input.manifestTool.id} requires a granted approval request.`,
+				status: 409,
+				details: {
+					approvalRequestId: input.approvalRequestId,
+					runId: input.run.id,
+					toolId: input.manifestTool.id,
+					approvalStatus: request?.status ?? null
+				}
+			});
+		}
+		const approval = await stores.approvals.createApprovalRequest({
+			agentId: input.agent.id,
+			runId: input.run.id,
+			toolId: input.manifestTool.id,
+			input: input.input,
+			requestedBy: input.auth,
+			metadata: {
+				toolSource: input.manifestTool.source,
+				displayName: input.manifestTool.displayName
+			}
+		});
+		if (input.run.status === "running") {
+			await stores.state.updateRun(input.run.id, { status: "paused" });
+			await stores.events.appendRunEvent({
+				runId: input.run.id,
+				type: "run.paused",
+				payload: {
+					reason: "approval_required",
+					approvalRequestId: approval.id,
+					toolId: input.manifestTool.id
+				},
+				sourceRefs: [{
+					type: "approval_request",
+					id: approval.id
+				}]
+			});
+		}
+		await stores.events.appendRunEvent({
+			runId: input.run.id,
+			type: "approval.requested",
+			payload: {
+				approvalRequestId: approval.id,
+				toolId: input.manifestTool.id,
+				displayName: input.manifestTool.displayName
+			},
+			sourceRefs: [...toolSourceRefs(input.manifestTool), {
+				type: "approval_request",
+				id: approval.id
+			}]
+		});
+		throw new HephError({
+			code: "HEPH3002",
+			title: "Approval required",
+			message: `Tool ${input.manifestTool.id} requires approval before execution.`,
+			status: 409,
+			details: {
+				approvalRequestId: approval.id,
+				runId: input.run.id,
+				toolId: input.manifestTool.id
+			}
+		});
+	}
+	async function callLocalTool(input) {
+		const tool = input.spec.tools.find((candidate) => candidate.id === input.manifestTool.id);
+		if (!tool) throw new HephError({
+			code: "HEPH3005",
+			title: "Local tool is not registered",
+			message: `Local tool ${input.manifestTool.id} is not registered on AgentSpec ${input.spec.id}.`,
+			status: 500,
+			details: {
+				toolId: input.manifestTool.id,
+				agentSpecId: input.spec.id
+			}
+		});
+		const parsedInput = tool.inputSchema.parse(input.input);
+		return tool.execute(parsedInput, {
+			auth: input.auth,
+			agent: input.agent,
+			run: input.run,
+			app,
+			signal: input.signal
+		});
+	}
+	async function callMcpTool(input) {
+		const binding = await stores.mcpBindings.getMcpBinding(input.manifestTool.bindingId);
+		if (!binding) throw new HephError({
+			code: "HEPH7001",
+			title: "MCP binding not found",
+			message: `MCP binding ${input.manifestTool.bindingId} was not found.`,
+			status: 500,
+			details: {
+				bindingId: input.manifestTool.bindingId,
+				toolId: input.manifestTool.id
+			}
+		});
+		const resolved = await resolveMcpBindingOrThrow({
+			resolver: mcpResolver,
+			auth: input.auth,
+			agent: input.agent,
+			binding,
+			app
+		});
+		return mcpToolExecutor.callTool({
+			auth: input.auth,
+			agent: input.agent,
+			run: input.run,
+			binding,
+			manifestTool: input.manifestTool,
+			resolved,
+			input: input.input,
+			app,
+			signal: input.signal
+		});
+	}
+	async function renderRunContext(runId) {
+		const run = await getRunOrThrow(stores, runId);
+		const agent = await getAgentOrThrow(stores, run.agentId);
+		const spec = await resolveSpecOrThrow(resolver, run.agentSpecId, run.auth ?? agent.auth);
+		const providerBlocks = await loadProviderBlocks(spec.contextProviders, {
+			auth: run.auth,
+			agent,
+			run,
+			spec,
+			input: run.input,
+			stores,
+			app
+		});
+		const builtInBlocks = createBuiltInBlocks({
+			agent,
+			spec,
+			run,
+			runtimePolicy: options.runtimePolicy ?? "Follow the active platform, security, tenant-boundary, and tool policies supplied by the runtime.",
+			toolPolicy: options.toolPolicy ?? "Use only the tools listed in the Run-scoped ToolManifest."
+		});
+		const rendered = renderer.render({
+			template: spec.contextTemplate ?? defaultContextTemplate,
+			blocks: [...builtInBlocks, ...providerBlocks],
+			runId: run.id,
+			input: runInputText(run.input),
+			runtime: { toolPolicy: options.toolPolicy ?? "Use only the tools listed in the Run-scoped ToolManifest." }
+		});
+		await stores.events.appendRunEvent({
+			runId: run.id,
+			type: "context.rendered",
+			payload: {
+				contextTemplateId: rendered.manifest.contextTemplateId,
+				contextTemplateVersion: rendered.manifest.contextTemplateVersion,
+				totalTokens: rendered.manifest.totalTokens,
+				blocks: rendered.manifest.blocks.map((block) => ({
+					key: block.key,
+					type: block.type,
+					tokens: block.tokens,
+					truncated: block.truncated
+				}))
+			}
+		});
+		return rendered;
+	}
+}
+function normalizeAgentSpecResolver(registration) {
+	if (isAgentSpecResolver(registration)) return registration;
+	const specs = /* @__PURE__ */ new Map();
+	if (Array.isArray(registration)) for (const spec of registration) specs.set(spec.id, spec);
+	else for (const [id, spec] of Object.entries(registration)) specs.set(id, spec);
+	return { async resolve(id) {
+		return specs.get(id) ?? null;
+	} };
+}
+function isAgentSpecResolver(registration) {
+	return typeof registration.resolve === "function";
+}
+async function resolveSpecOrThrow(resolver, id, auth) {
+	const spec = await resolver.resolve(id, { auth });
+	if (!spec) throw new HephError({
+		code: "HEPH1001",
+		title: "Agent spec not found",
+		message: `Agent spec ${id} was not found.`,
+		status: 404,
+		details: { agentSpecId: id }
+	});
+	return spec;
+}
+async function getAgentOrThrow(stores, agentId) {
+	const agent = await stores.state.getAgentSession(agentId);
+	if (!agent) throw new HephError({
+		code: "HEPH5001",
+		title: "AgentSession not found",
+		message: `AgentSession ${agentId} was not found.`,
+		status: 404,
+		details: { agentId }
+	});
+	return agent;
+}
+async function getRunOrThrow(stores, runId) {
+	const run = await stores.state.getRun(runId);
+	if (!run) throw new HephError({
+		code: "HEPH4001",
+		title: "Run not found",
+		message: `Run ${runId} was not found.`,
+		status: 404,
+		details: { runId }
+	});
+	return run;
+}
+async function loadProviderBlocks(providers, ctx) {
+	const blocks = [];
+	for (const provider of providers) {
+		const loaded = await provider.load(ctx);
+		if (!loaded) continue;
+		if (Array.isArray(loaded)) blocks.push(...loaded);
+		else blocks.push(loaded);
+	}
+	return blocks;
+}
+function enforceMcpPolicy(spec, binding) {
+	if (!spec.mcp) throw new HephError({
+		code: "HEPH7001",
+		title: "MCP is disabled for this AgentSpec",
+		message: `AgentSpec ${spec.id} does not allow dynamic MCP bindings.`,
+		status: 422,
+		details: {
+			agentSpecId: spec.id,
+			capabilityId: binding.capabilityId
+		}
+	});
+	if (!spec.mcp.allowCapabilities.includes(binding.capabilityId)) throw new HephError({
+		code: "HEPH7001",
+		title: "MCP capability is not allowed",
+		message: `AgentSpec ${spec.id} does not allow MCP capability ${binding.capabilityId}.`,
+		status: 422,
+		details: {
+			agentSpecId: spec.id,
+			capabilityId: binding.capabilityId
+		}
+	});
+	if (binding.allowTools === "all" && spec.mcp.allowAllTools !== true) throw new HephError({
+		code: "HEPH7001",
+		title: "MCP allowTools all is not allowed",
+		message: `AgentSpec ${spec.id} must opt in before an MCP binding can expose all tools.`,
+		status: 422,
+		details: {
+			agentSpecId: spec.id,
+			capabilityId: binding.capabilityId
+		}
+	});
+}
+function enforceSkillPolicy(spec, skillId) {
+	if (!spec.skills) throw new HephError({
+		code: "HEPH8004",
+		title: "Skills are disabled for this AgentSpec",
+		message: `AgentSpec ${spec.id} does not allow session skill activation.`,
+		status: 422,
+		details: {
+			agentSpecId: spec.id,
+			skillId
+		}
+	});
+	if (spec.skills.allow !== "all" && !spec.skills.allow.includes(skillId)) throw new HephError({
+		code: "HEPH8004",
+		title: "Skill is not allowed",
+		message: `AgentSpec ${spec.id} does not allow skill ${skillId}.`,
+		status: 422,
+		details: {
+			agentSpecId: spec.id,
+			skillId
+		}
+	});
+}
+async function resolveMcpBindingOrThrow(input) {
+	if (!input.resolver) throw new HephError({
+		code: "HEPH7001",
+		title: "MCP binding resolver is not configured",
+		message: "createHeph({ mcp: { resolver } }) is required before MCP bindings can be resolved.",
+		status: 422,
+		details: {
+			bindingId: input.binding.id,
+			capabilityId: input.binding.capabilityId
+		}
+	});
+	const resolved = await input.resolver.resolve({
+		auth: input.auth,
+		agent: input.agent,
+		binding: input.binding,
+		app: input.app
+	});
+	if (resolved.transport !== "streamable_http") throw new HephError({
+		code: "HEPH7001",
+		title: "Unsupported MCP transport",
+		message: "The MCP MVP supports only Streamable HTTP bindings.",
+		status: 422,
+		details: {
+			bindingId: input.binding.id,
+			transport: resolved.transport
+		}
+	});
+	if (!resolved.endpoint.trim()) throw new HephError({
+		code: "HEPH7001",
+		title: "MCP endpoint is missing",
+		message: "Resolved MCP bindings must include a Streamable HTTP endpoint.",
+		status: 422,
+		details: { bindingId: input.binding.id }
+	});
+	return resolved;
+}
+function validateMcpCatalog(binding, resolved) {
+	const toolNames = new Set(resolved.tools.map((tool) => tool.name));
+	if (resolved.tools.filter((tool) => !tool.name.trim()).length > 0) throw new HephError({
+		code: "HEPH7001",
+		title: "MCP tool catalog is invalid",
+		message: "MCP tool catalog entries must include non-empty tool names.",
+		status: 422,
+		details: {
+			bindingId: binding.id,
+			capabilityId: binding.capabilityId
+		}
+	});
+	if (binding.allowTools !== "all") {
+		const unknownTools = binding.allowTools.filter((toolName) => !toolNames.has(toolName));
+		if (unknownTools.length > 0) throw new HephError({
+			code: "HEPH7001",
+			title: "MCP allowTools contains unknown tools",
+			message: "MCP binding allowTools must name tools present in the resolved catalog.",
+			status: 422,
+			details: {
+				bindingId: binding.id,
+				capabilityId: binding.capabilityId,
+				unknownTools
+			}
+		});
+	}
+}
+function filterMcpCatalog(binding, resolved) {
+	if (binding.allowTools === "all") return resolved.tools;
+	const allowSet = new Set(binding.allowTools);
+	return resolved.tools.filter((tool) => allowSet.has(tool.name));
+}
+function toolSourceRefs(tool, approvalRequestId) {
+	const refs = tool.source === "mcp" ? [{
+		type: "mcp_binding",
+		id: tool.bindingId
+	}] : [];
+	if (approvalRequestId) refs.push({
+		type: "approval_request",
+		id: approvalRequestId
+	});
+	return refs;
+}
+function createBuiltInBlocks(input) {
+	return [
+		{
+			key: "runtimePolicy",
+			type: "policy",
+			content: input.runtimePolicy
+		},
+		{
+			key: "agentIdentity",
+			type: "agent_identity",
+			content: input.spec.instructions
+		},
+		{
+			key: "currentTask",
+			type: "input",
+			content: runInputText(input.run.input)
+		},
+		{
+			key: "sessionState",
+			type: "state",
+			content: JSON.stringify(input.agent.state, null, 2)
+		},
+		{
+			key: "skills",
+			type: "skill",
+			content: formatSkillsBlock(input.run.skillManifest),
+			sourceRefs: input.run.skillManifest?.skills.map((skill) => ({
+				type: "skill_binding",
+				id: skill.bindingId
+			})) ?? []
+		},
+		{
+			key: "toolManifest",
+			type: "tool_manifest",
+			content: JSON.stringify(input.run.toolManifest ?? createLocalToolManifest(input.run.id, input.spec.tools), null, 2)
+		}
+	];
+}
+function createLocalToolManifest(runId, tools) {
+	return {
+		runId,
+		tools: tools.map(toLocalManifestTool),
+		createdAt: /* @__PURE__ */ new Date()
+	};
+}
+function toLocalManifestTool(tool) {
+	return {
+		id: tool.id,
+		displayName: tool.id,
+		source: "local",
+		localToolId: tool.id,
+		description: tool.description,
+		inputSchema: tool.jsonSchema,
+		sideEffect: tool.sideEffect,
+		requiresApproval: tool.requiresApproval,
+		metadata: {}
+	};
+}
+function toMcpManifestTool(binding, tool) {
+	const sideEffect = tool.sideEffect ?? null;
+	return {
+		id: `mcp.${binding.id}.${tool.name}`,
+		displayName: `${binding.capabilityId}.${tool.name}`,
+		source: "mcp",
+		bindingId: binding.id,
+		capabilityId: binding.capabilityId,
+		remoteToolName: tool.name,
+		transport: "streamable_http",
+		description: tool.description ?? "",
+		inputSchema: tool.inputSchema ?? {
+			type: "object",
+			additionalProperties: true
+		},
+		sideEffect,
+		requiresApproval: tool.requiresApproval ?? sideEffect !== false,
+		metadata: tool.metadata ?? {}
+	};
+}
+function normalizeRunInput(input) {
+	if (typeof input === "string") return {
+		type: "user.message",
+		text: input
+	};
+	return input;
+}
+function renderDeferredToolResultContent(operation) {
+	const lines = [`Deferred tool operation ${operation.id} ${operation.status}.`];
+	lines.push(`- toolId: ${operation.toolId}`);
+	lines.push(`- runId: ${operation.runId}`);
+	if (operation.toolCallId) lines.push(`- toolCallId: ${operation.toolCallId}`);
+	if (operation.error) lines.push(`- error: ${operation.error.message}`);
+	if (operation.result !== null && operation.result !== void 0) lines.push(`- result: ${JSON.stringify(operation.result)}`);
+	return lines.join("\n");
+}
+function addMessageIdToRunInput(input, messageId) {
+	return {
+		...input,
+		messageIds: [...input.messageIds ?? [], messageId]
+	};
+}
+function reduceInboxEvents(events, textSeparator) {
+	const messageIds = unique(events.flatMap((event) => event.input.messageIds ?? []));
+	const textEvents = events.filter((event) => "text" in event.input);
+	if (textEvents.length === events.length) {
+		const first = textEvents[0];
+		return {
+			type: first?.input.type === "steering.message" || first?.input.type === "follow_up.message" ? first.input.type : "user.message",
+			text: textEvents.map((event) => "text" in event.input ? event.input.text : "").join(textSeparator),
+			messageIds,
+			payload: {
+				inboxEventIds: events.map((event) => event.id),
+				reducedInboxEvents: events.map(toReducedInboxEvent)
+			}
+		};
+	}
+	if (events.length === 1) return {
+		...events[0].input,
+		messageIds,
+		payload: {
+			...typeof events[0].input.payload === "object" && events[0].input.payload !== null ? events[0].input.payload : {},
+			reducedInboxEvents: events.map(toReducedInboxEvent)
+		}
+	};
+	return {
+		type: "system.event",
+		messageIds,
+		payload: {
+			inboxEvents: events.map((event) => ({
+				id: event.id,
+				type: event.type,
+				input: event.input
+			})),
+			reducedInboxEvents: events.map(toReducedInboxEvent)
+		}
+	};
+}
+function normalizeMaxEventsPerRun(value) {
+	if (value === null) return;
+	if (value === void 0) return 20;
+	if (!Number.isFinite(value) || value < 1) throw new HephError({
+		code: "HEPH4006",
+		title: "Invalid inbox reducer configuration",
+		message: "inbox.maxEventsPerRun must be a positive number or null.",
+		status: 422,
+		details: { maxEventsPerRun: value }
+	});
+	return Math.floor(value);
+}
+function toReducedInboxEvent(event) {
+	const input = event.input;
+	return {
+		inboxEventId: event.id,
+		type: event.type,
+		messageIds: input.messageIds ?? [],
+		text: "text" in input ? input.text : null
+	};
+}
+function firstAuth(events) {
+	return events.find((event) => event.auth !== null)?.auth ?? null;
+}
+function toInboxSourceRefs(events) {
+	return events.map((event) => ({
+		type: "inbox_event",
+		id: event.id
+	}));
+}
+function toRunError(error) {
+	const runError = {
+		message: error instanceof Error ? error.message : String(error),
+		details: toErrorDetails(error)
+	};
+	if (error instanceof HephError) runError.code = error.code;
+	return runError;
+}
+function shouldRethrowToolCallAttemptError(error) {
+	if (!(error instanceof HephError)) return false;
+	return error.code === "HEPH3002" || error.code === "HEPH3003" || error.code === "HEPH3004";
+}
+function isTerminalRun(run) {
+	return run.status === "completed" || run.status === "failed" || run.status === "cancelled";
+}
+function unique(values) {
+	return Array.from(new Set(values));
+}
+function runInputText(input) {
+	return "text" in input ? input.text : JSON.stringify(input.payload ?? {});
+}
+function formatSkillsBlock(manifest) {
+	if (!manifest || manifest.skills.length === 0) return "";
+	return manifest.skills.map((skill) => {
+		const version = skill.version ? `@${skill.version}` : "";
+		const referenceLines = skill.availableReferences.length === 0 ? "" : `\nAvailable references:\n${skill.availableReferences.map((ref) => `- ${ref.id}: ${ref.pathOrRef}`).join("\n")}`;
+		return `# ${skill.name}${version}\n\nDescription: ${skill.description}\n\nInstructions:\n${skill.instructions}${referenceLines}`;
+	}).join("\n\n---\n\n");
+}
+function filterSkillReferences(references, allowReferences) {
+	if (allowReferences === "all") return references.map(cloneSkillResourceRef);
+	const allowSet = new Set(allowReferences);
+	return references.filter((reference) => allowSet.has(reference.id)).map(cloneSkillResourceRef);
+}
+function cloneSkillResourceRef(ref) {
+	return {
+		...ref,
+		metadata: { ...ref.metadata }
+	};
+}
+async function sha256Text(value) {
+	const bytes = new TextEncoder().encode(value);
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+	return `sha256:${Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function parseMcpResponseBody(body, contentType) {
+	const trimmed = body.trim();
+	if (!trimmed) return null;
+	if (contentType?.includes("text/event-stream")) {
+		const lastData = trimmed.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).filter((line) => line && line !== "[DONE]").at(-1);
+		if (!lastData) return null;
+		try {
+			return JSON.parse(lastData);
+		} catch {
+			return lastData;
+		}
+	}
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		return trimmed;
+	}
+}
+function isJsonRpcError(value) {
+	return isRecord(value) && "error" in value && value.error !== void 0 && value.error !== null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { ContextRenderer as A, ContextProvider as C, defineContextProvider as D, defineAgent as E, isHephError as F, toErrorDetails as I, estimateTokens as M, messagesToText as N, defineContextTemplate as O, HephError as P, AgentSpec as S, Tool as T, createMessageId as _, InProcessQueue as a, createSkillBindingId as b, recentMessages as c, createApprovalRequestId as d, createDeferredToolOperationId as f, createMemoryId as g, createMcpBindingId as h, createInMemorySkillCatalog as i, defaultContextTemplate as j, defineTool as k, threadState as l, createInboxEventId as m, createHeph as n, block as o, createId as p, InMemoryHephStore as r, memorySearch as s, StreamableHttpMcpToolExecutor as t, createAgentSessionId as u, createRunEventId as v, ContextTemplate as w, MinimalRunExecutor as x, createRunId as y };
+
+//# sourceMappingURL=src-DeheByi4.mjs.map