@economic/agents 2.1.7 → 2.2.0

package/dist/v1.mjs

@@ -0,0 +1,931 @@
+import { n as extractTokenFromConnectRequest, r as verifyJwt, t as createAgentTracer } from "./telemetry-BDxmv_R7.mjs";
+import { Output, convertToModelMessages, generateText, jsonSchema, stepCountIs, streamText, tool } from "ai";
+import { Agent as Agent$1, callable, getCurrentAgent, routeAgentRequest as routeAgentRequest$1 } from "agents";
+import { AIChatAgent } from "@cloudflare/ai-chat";
+//#region src/server/shared/features/skills/index.ts
+const TOOL_NAME_ACTIVATE_SKILL = "activate_skill";
+const TOOL_NAME_LIST_CAPABILITIES = "list_capabilities";
+const SKILL_STATE_SENTINEL = "\n__SKILLS_STATE__:";
+function buildActivateSkillDescription(skills) {
+	return [
+		"Load additional skills to help with the user's request.",
+		"Call this BEFORE attempting actions that need tools from unloaded skills.",
+		"",
+		"Available skills:",
+		skills.map((s) => `• ${s.name} — ${s.description}`).join("\n")
+	].join("\n");
+}
+function buildAvailableSkillList(skills) {
+	return skills.map((s) => `**${s.name}**: ${s.description}`).join("\n");
+}
+const LIST_CAPABILITIES_DESCRIPTION = "List all tools currently available to you, which skills are loaded, and which can still be loaded. Call this when the user asks about your capabilities or what you can do.";
+/**
+* Creates a skill loading system for use with the Vercel AI SDK.
+*
+* The agent starts with only its always-on tools active. The LLM can call
+* activate_skill to load skill tools on demand. Which skills are loaded is
+* communicated to the CF layer via a sentinel in the activate_skill result
+* and persisted to DO SQLite — no D1 or message-history parsing required.
+*/
+function createSkills(config) {
+	const { tools: alwaysOnTools, skills } = config;
+	const loadedSkills = new Set(config.initialLoadedSkills ?? []);
+	const skillMap = new Map(skills.map((s) => [s.name, s]));
+	const availableSkillList = skills.length > 0 ? buildAvailableSkillList(skills) : "";
+	const allTools = {};
+	Object.assign(allTools, alwaysOnTools);
+	for (const skill of skills) Object.assign(allTools, skill.tools);
+	function getActiveToolNames() {
+		const names = [
+			TOOL_NAME_ACTIVATE_SKILL,
+			TOOL_NAME_LIST_CAPABILITIES,
+			...Object.keys(alwaysOnTools)
+		];
+		for (const skillName of loadedSkills) {
+			const skill = skillMap.get(skillName);
+			if (!skill) continue;
+			for (const toolName of Object.keys(skill.tools)) if (!names.includes(toolName)) names.push(toolName);
+		}
+		return names;
+	}
+	function getLoadedGuidance() {
+		const sections = [...loadedSkills].flatMap((name) => {
+			const skill = skillMap.get(name);
+			if (!skill?.guidance) return [];
+			return [`**${skill.name}**\n${skill.guidance}`];
+		});
+		if (sections.length === 0) return "";
+		return sections.join("\n\n");
+	}
+	allTools[TOOL_NAME_ACTIVATE_SKILL] = tool({
+		description: buildActivateSkillDescription(skills),
+		inputSchema: jsonSchema({
+			type: "object",
+			properties: { skills: {
+				type: "array",
+				items: {
+					type: "string",
+					enum: skills.map((s) => s.name)
+				},
+				description: "Skills to load"
+			} },
+			required: ["skills"]
+		}),
+		execute: async ({ skills: requested }) => {
+			const newlyLoaded = [];
+			for (const skillName of requested) {
+				if (!skillMap.get(skillName)) continue;
+				if (loadedSkills.has(skillName)) continue;
+				loadedSkills.add(skillName);
+				newlyLoaded.push(skillName);
+			}
+			if (newlyLoaded.length > 0) return `Loaded: ${newlyLoaded.join(", ")}.${SKILL_STATE_SENTINEL}${JSON.stringify([...loadedSkills])}`;
+			return "All requested skills were already loaded.";
+		}
+	});
+	allTools[TOOL_NAME_LIST_CAPABILITIES] = tool({
+		description: LIST_CAPABILITIES_DESCRIPTION,
+		inputSchema: jsonSchema({
+			type: "object",
+			properties: {},
+			required: []
+		}),
+		execute: async () => {
+			const activeNames = getActiveToolNames();
+			const loadedNames = [...loadedSkills];
+			const unloaded = skills.filter((s) => !loadedSkills.has(s.name)).map((s) => s.name);
+			return [
+				`Active tools (${activeNames.length}): ${activeNames.join(", ")}`,
+				`Loaded skills: ${loadedNames.length > 0 ? loadedNames.join(", ") : "none"}`,
+				`Available to load: ${unloaded.length > 0 ? unloaded.join(", ") : "none"}`
+			].join("\n");
+		}
+	});
+	const prepareStep = async () => {
+		return { activeTools: getActiveToolNames() };
+	};
+	return {
+		tools: allTools,
+		activeTools: getActiveToolNames(),
+		prepareStep,
+		availableSkillList,
+		getLoadedGuidance,
+		getLoadedSkills() {
+			return [...loadedSkills];
+		}
+	};
+}
+function isEphemeralSkillToolPart(part) {
+	if (!part || typeof part !== "object" || !("toolCallId" in part) || !("type" in part)) return false;
+	const { type } = part;
+	return type === `tool-list_capabilities` || type === `tool-activate_skill`;
+}
+/** Creates the `skill_state` table in DO SQLite if it does not exist yet. */
+function ensureSkillTable(sql) {
+	sql`CREATE TABLE IF NOT EXISTS skill_state (id INTEGER PRIMARY KEY, active_skills TEXT NOT NULL DEFAULT '[]')`;
+}
+/**
+* Reads the persisted list of loaded skill names from DO SQLite.
+* Returns an empty array if the table is missing or the row does not exist.
+*/
+function getStoredSkills(sql) {
+	try {
+		ensureSkillTable(sql);
+		const rows = sql`SELECT active_skills FROM skill_state WHERE id = 1`;
+		if (rows.length === 0) return [];
+		return JSON.parse(rows[0].active_skills);
+	} catch {
+		return [];
+	}
+}
+/**
+* Persists the current list of loaded skill names to DO SQLite.
+* Upserts the single `skill_state` row (id = 1).
+*/
+function saveSkillStateFromMessages(sql, messages) {
+	let latestSkillState;
+	for (const msg of messages) {
+		if (msg.role !== "assistant" || !msg.parts) continue;
+		for (const part of msg.parts) {
+			if (!("toolCallId" in part)) continue;
+			if (part.type !== `tool-activate_skill` || typeof part.output !== "string") continue;
+			const sentinelIndex = part.output.indexOf(SKILL_STATE_SENTINEL);
+			if (sentinelIndex !== -1) try {
+				const stateJson = part.output.slice(sentinelIndex + 18);
+				latestSkillState = JSON.parse(stateJson);
+			} catch {}
+		}
+	}
+	if (latestSkillState == void 0) return;
+	ensureSkillTable(sql);
+	sql`INSERT OR REPLACE INTO skill_state(id, active_skills) VALUES(1, ${JSON.stringify(latestSkillState)})`;
+}
+//#endregion
+//#region src/server/shared/util/llm.ts
+function buildSystemPromptWithSkills(basePrompt, availableSkillList, loadedGuidance) {
+	let prompt = `${basePrompt}
+
+## Tools
+
+### Loading More Tools:
+Use \`activate_skill\` to load these skills. NEVER ask the user for permission to load a skill - just load it silently when relevant. The user should not be aware of skills or tools; activate them autonomously based on the request:
+
+${availableSkillList}`;
+	if (loadedGuidance) prompt += `
+
+### Loaded skill instructions:
+The following skills are currently active. Apply their instructions when using the corresponding tools.
+
+${loadedGuidance}`;
+	return prompt.trim();
+}
+/**
+* Convention: tools can include a `sources` array in their return value to surface
+* source URLs in the message stream. This transform detects it automatically.
+*
+* ```typescript
+* // In any tool's execute function:
+* return { myContent: "...", sources: [{ url: "https://...", title: "Page title" }] };
+* ```
+*/
+function buildSourcesTransform(additional) {
+	const sourcesTransform = () => new TransformStream({ transform(chunk, controller) {
+		controller.enqueue(chunk);
+		if (chunk.type !== "tool-result") return;
+		const output = chunk.output;
+		if (!output || typeof output !== "object" || Array.isArray(output)) return;
+		const sources = output.sources;
+		if (!Array.isArray(sources)) return;
+		for (const source of sources) {
+			if (!source || typeof source !== "object") continue;
+			const s = source;
+			if (typeof s.url !== "string") continue;
+			controller.enqueue({
+				type: "source",
+				sourceType: "url",
+				id: crypto.randomUUID(),
+				url: s.url,
+				...typeof s.title === "string" ? { title: s.title } : {}
+			});
+		}
+	} });
+	if (!additional) return sourcesTransform;
+	return [sourcesTransform, ...Array.isArray(additional) ? additional : [additional]];
+}
+/**
+* Builds the parameter object for a Vercel AI SDK `streamText` or `generateText` call.
+*
+* Handles skill wiring (`activate_skill`, `list_capabilities`, `prepareStep`).
+*
+* The returned object can be spread directly into `streamText` or `generateText`:
+*
+* ```typescript
+* const params = buildLLMParams({ ... });
+* return streamText(params).toUIMessageStreamResponse();
+* ```
+*/
+function buildLLMParams(config) {
+	const { activeSkills = [], skills, experimental_transform, system, tools = {}, ...rest } = config;
+	const composedTransform = buildSourcesTransform(experimental_transform);
+	const baseParams = {
+		...rest,
+		system,
+		tools,
+		stopWhen: rest.stopWhen ?? stepCountIs(20),
+		experimental_transform: composedTransform
+	};
+	if (!skills?.length) return baseParams;
+	const skillsCtx = createSkills({
+		tools,
+		skills,
+		initialLoadedSkills: activeSkills
+	});
+	const systemWithSkills = buildSystemPromptWithSkills(typeof system === "string" ? system : void 0, skillsCtx.availableSkillList, skillsCtx.getLoadedGuidance());
+	const prepareStep = async (stepOptions) => {
+		return {
+			activeTools: (await skillsCtx.prepareStep(stepOptions) ?? {}).activeTools ?? [],
+			system: systemWithSkills
+		};
+	};
+	return {
+		...baseParams,
+		system: systemWithSkills,
+		tools: skillsCtx.tools,
+		activeTools: skillsCtx.activeTools,
+		prepareStep
+	};
+}
+//#endregion
+//#region src/server/v1/route-agent-request.ts
+async function routeAgentRequest(request, env, options) {
+	const response = await routeAgentRequest$1(request, env, options);
+	if (!response) return null;
+	const protocol = request.headers.get("Sec-WebSocket-Protocol");
+	if (response.status === 101 && protocol) {
+		const newResponse = new Response(null, response);
+		newResponse.headers.set("Sec-WebSocket-Protocol", protocol.split(",")[0].trim());
+		return newResponse;
+	}
+	return response;
+}
+//#endregion
+//#region src/server/v1/agent/Agent.ts
+/**
+* Base agent for Cloudflare Agents SDK Durable Objects with lazy skill loading
+* and `buildLLMParams` wiring.
+*
+* Handles CF infrastructure concerns: DO SQLite persistence for loaded skill state.
+*
+* For chat agents with message history, compaction, and conversation recording,
+* extend {@link ChatAgent} instead.
+*/
+var Agent = class extends Agent$1 {
+	clientIp;
+	forwardedFor;
+	/**
+	* The user context for the session.
+	* Define getUserContext to set a user context.
+	*/
+	get userContext() {
+		const { connection } = getCurrentAgent();
+		return (connection?.state)?.userContext ?? {};
+	}
+	/**
+	* Returns the user ID from the durable object name.
+	*/
+	getUserId() {
+		return this.name.split(":")[0];
+	}
+	async onConnect(connection, ctx) {
+		this.clientIp = ctx.request.headers.get("CF-Connecting-IP") ?? ctx.request.headers.get("X-Forwarded-For")?.split(",")[0]?.trim();
+		this.forwardedFor = ctx.request.headers.get("X-Forwarded-For") ?? void 0;
+		if (!this.env.AGENT_DB) {
+			console.error("[Agent] Connection rejected: no AGENT_DB bound");
+			connection.close(3e3, "Could not connect to agent");
+			return;
+		}
+		if (!this.env.AGENTS_AUDIT_LOGS) {
+			console.error("[Agent] Connection rejected: no AGENTS_AUDIT_LOGS bound. Audit logs are required.");
+			connection.close(3e3, "Could not connect to agent");
+			return;
+		}
+		if (!this.env.AGENTS_ANALYTICS) console.warn("[Agent] No AGENTS_ANALYTICS bound. Analytics will not be collected.");
+		if (!this.getUserId()) {
+			console.error("[Agent] Connection rejected: name must be in the format userId:uniqueChatId");
+			connection.close(3e3, "Could not connect to agent");
+			return;
+		}
+		if (this.getJwtAuthConfig) {
+			const config = this.getJwtAuthConfig(ctx.request);
+			if (config) {
+				let result;
+				try {
+					result = await verifyJwt(ctx.request, config);
+				} catch (error) {
+					console.error("[Agent] JWT verification error", error);
+					connection.close(4001, "Unauthorized");
+					return;
+				}
+				if (!result.success) {
+					connection.close(result.status === 401 ? 4001 : 4003, result.message);
+					return;
+				}
+				const token = extractTokenFromConnectRequest(ctx.request);
+				if (token) {
+					const userContext = await this.getUserContext?.(token);
+					if (userContext) connection.setState({ userContext });
+				}
+			}
+		}
+		return super.onConnect(connection, ctx);
+	}
+	/**
+	* Builds the parameter object for a `streamText` or `generateText` call,
+	* pre-filling `activeSkills` from this agent instance.
+	*/
+	async buildLLMParams(config) {
+		const activeSkills = await getStoredSkills(this.sql.bind(this));
+		const experimental_context = {
+			...config.experimental_context,
+			...config.options?.body,
+			_userContext: this.userContext
+		};
+		return buildLLMParams({
+			...config,
+			activeSkills,
+			experimental_context,
+			experimental_telemetry: {
+				...config.experimental_telemetry,
+				isEnabled: true,
+				tracer: createAgentTracer(this.env.AGENTS_AUDIT_LOGS, this.env.AGENTS_ANALYTICS, {
+					agentName: this.constructor.name,
+					durableObjectName: this.name,
+					actorId: this.getUserId(),
+					...this.clientIp ? { clientIp: this.clientIp } : {},
+					...this.forwardedFor ? { forwardedFor: this.forwardedFor } : {}
+				}),
+				metadata: {
+					agentName: this.constructor.name,
+					version: "v1",
+					durableObjectName: this.name,
+					actorId: this.getUserId(),
+					...this.clientIp ? { clientIp: this.clientIp } : {},
+					...this.forwardedFor ? { forwardedFor: this.forwardedFor } : {},
+					...config.experimental_telemetry?.metadata
+				}
+			}
+		});
+	}
+};
+const TOOL_RESULT_PREVIEW_CHARS = 200;
+const SUMMARY_MAX_TOKENS = 4e3;
+/**
+* Estimates token count for a message array using a 3.5 chars/token
+* approximation. Counts text from text/reasoning parts, tool inputs/outputs.
+*/
+function estimateMessagesTokens(messages) {
+	let totalChars = 0;
+	for (const msg of messages) {
+		if (typeof msg.content === "string") {
+			totalChars += msg.content.length;
+			continue;
+		}
+		for (const part of msg.content) if (part.type === "text" || part.type === "reasoning") totalChars += part.text.length;
+		else if (part.type === "tool-call") totalChars += JSON.stringify(part.input).length;
+		else if (part.type === "tool-result") {
+			const output = part.output;
+			totalChars += typeof output === "string" ? output.length : JSON.stringify(output).length;
+		}
+	}
+	return Math.ceil(totalChars / 3.5);
+}
+/**
+* Renders messages as human-readable text for the compaction summary prompt.
+*/
+function formatMessagesForSummary(messages) {
+	const lines = [];
+	for (const msg of messages) {
+		const roleLabel = msg.role.charAt(0).toUpperCase() + msg.role.slice(1);
+		const parts = [];
+		if (typeof msg.content === "string") {
+			if (msg.content.trim()) parts.push(msg.content.trim());
+		} else for (const part of msg.content) if (part.type === "text" || part.type === "reasoning") {
+			const text = part.text.trim();
+			if (text) parts.push(text);
+		} else if (part.type === "tool-call") {
+			const p = part;
+			parts.push(`[Tool call: ${p.toolName}]`);
+		} else if (part.type === "tool-result") {
+			const p = part;
+			const rawOutput = typeof p.output === "string" ? p.output : JSON.stringify(p.output);
+			const preview = rawOutput.slice(0, TOOL_RESULT_PREVIEW_CHARS);
+			const ellipsis = rawOutput.length > TOOL_RESULT_PREVIEW_CHARS ? "..." : "";
+			parts.push(`[Tool: ${p.toolName}, result: ${preview}${ellipsis}]`);
+		}
+		if (parts.length > 0) lines.push(`${roleLabel}: ${parts.join(" ")}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Calls the model to produce a concise summary of old + recent message windows.
+*/
+async function generateCompactionSummary(oldMessages, recentMessages, model) {
+	const prompt = `Summarize this conversation history concisely for an AI assistant to continue the conversation.
+Focus MORE on recent exchanges (what the user was working on, what tools were used, what was found).
+Include key facts, decisions, and context needed to continue the conversation.
+Keep entity names, numbers, file paths, and specific details that might be referenced later.
+Do NOT include pleasantries or meta-commentary - just the essential context.
+
+OLDER MESSAGES (summarize briefly):
+${formatMessagesForSummary(oldMessages)}
+
+RECENT MESSAGES (summarize with more detail - this is where the user currently is):
+${formatMessagesForSummary(recentMessages)}
+
+Write a concise summary:`;
+	try {
+		const { text } = await generateText({
+			model,
+			messages: [{
+				role: "user",
+				content: prompt
+			}],
+			maxOutputTokens: SUMMARY_MAX_TOKENS
+		});
+		return text || "Unable to summarize conversation history.";
+	} catch (error) {
+		console.error("Compaction summarization error:", error);
+		return "Unable to summarize conversation history.";
+	}
+}
+/**
+* Summarizes older messages into a single system message and appends the
+* recent verbatim tail. Returns messages unchanged if already short enough.
+*/
+async function compactMessages(messages, model, tailSize) {
+	if (messages.length <= tailSize) return messages;
+	const splitIndex = messages.length - tailSize;
+	const oldMessages = messages.slice(0, splitIndex);
+	const recentTail = messages.slice(splitIndex);
+	return [{
+		role: "system",
+		content: `[Conversation summary - older context was compacted]\n${await generateCompactionSummary(oldMessages, recentTail, model)}`
+	}, ...recentTail];
+}
+/**
+* Entry point for compaction. Returns messages unchanged when model is
+* undefined or estimated token count is under COMPACT_TOKEN_THRESHOLD.
+*/
+async function compactIfNeeded(messages, model, tailSize) {
+	if (!model || estimateMessagesTokens(messages) <= 14e4) return messages;
+	return compactMessages(messages, model, tailSize);
+}
+//#endregion
+//#region src/server/v1/agent-chat/features/conversations/conversations.ts
+/**
+* Renders only the user- and assistant-visible text parts of a message
+* array for conversation title/summary generation.
+*
+* Tool calls, tool results, system messages, and reasoning parts are
+* intentionally excluded so the model receives a clean transcript.
+*/
+function formatMessagesForConversationSummary(messages) {
+	const lines = [];
+	for (const message of messages) {
+		if (message.role !== "user" && message.role !== "assistant") continue;
+		let text = "";
+		if (typeof message.content === "string") text = message.content.trim();
+		else text = message.content.filter((part) => part.type === "text").map((part) => part.text.trim()).filter(Boolean).join(" ");
+		if (!text) continue;
+		const roleLabel = message.role === "user" ? "User" : "Assistant";
+		lines.push(`${roleLabel}: ${text}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Number of recent messages passed to `generateSummary` for rolling
+* summarization. Keeping this bounded prevents the prompt growing
+* unboundedly regardless of conversation length.
+*/
+const SUMMARY_CONTEXT_MESSAGES = 15;
+async function recordConversationSummary(db, durableObjectName, messages, model) {
+	if (!await getConversationSummary(db, durableObjectName)) {
+		const { title, summary } = await generateTitleAndSummary(messages, model);
+		await upsertConversationSummary(db, durableObjectName, title, summary);
+	} else if (messages.length <= 7 || messages.length % SUMMARY_CONTEXT_MESSAGES === 0) await generateConversationSummary(db, durableObjectName, messages, model);
+}
+/**
+* Records a conversation row in the `conversations` D1 table.
+*
+* Called by `ChatAgentHarness` after every turn. On first call for a given
+* `durableObjectName` the row is inserted with `created_at` set to now,
+* and with the provided `title` and `summary` if supplied.
+* On subsequent calls only `updated_at` is refreshed —
+* `created_at`, `title`, and `summary` are never overwritten, preserving
+* any user edits.
+*/
+async function upsertConversationSummary(db, durableObjectName, title, summary) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	await db.prepare(`INSERT INTO conversations (durable_object_name, title, summary, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(durable_object_name) DO UPDATE SET
+         updated_at = excluded.updated_at`).bind(durableObjectName, title ?? null, summary ?? null, now, now).run();
+}
+/**
+* Returns the current `title` and `summary` for a conversation row,
+* or `null` if the row does not exist yet.
+*/
+async function getConversationSummary(db, durableObjectName) {
+	return await db.prepare(`SELECT title, summary FROM conversations WHERE durable_object_name = ?`).bind(durableObjectName).first() ?? null;
+}
+/**
+* Returns all conversations for a user, ordered by most recent.
+*/
+async function getConversations(db, userId) {
+	const { results } = await db.prepare(`SELECT * FROM conversations WHERE durable_object_name LIKE ? ORDER BY updated_at DESC`).bind(`${userId}:%`).all();
+	return results;
+}
+/**
+* Deletes a conversation row from the `conversations` D1 table.
+*/
+async function deleteConversationRow(db, durableObjectName) {
+	await db.prepare(`DELETE FROM conversations WHERE durable_object_name = ?`).bind(durableObjectName).run();
+}
+/**
+* Writes a generated `title` and `summary` back to the `conversations` row.
+*/
+async function updateConversationSummary(db, durableObjectName, title, summary) {
+	await db.prepare(`UPDATE conversations SET title = ?, summary = ? WHERE durable_object_name = ?`).bind(title, summary, durableObjectName).run();
+}
+/**
+* Generates a title and summary for a conversation using the provided model.
+* Returns the result without writing to D1.
+*
+* Pass `existingSummary` so the model can detect direction changes when
+* updating an existing summary. Omit it (or pass undefined) for the initial
+* generation.
+*
+* Only the last `SUMMARY_CONTEXT_MESSAGES` messages are used to keep the
+* prompt bounded regardless of total conversation length.
+*/
+async function generateTitleAndSummary(messages, model, existingSummary) {
+	const recentMessages = await convertToModelMessages(messages.slice(-SUMMARY_CONTEXT_MESSAGES));
+	const previousContext = existingSummary ? `Previous summary:\n${existingSummary}\n\nMost recent messages:` : "Conversation:";
+	const { output } = await generateText({
+		model,
+		output: Output.object({ schema: jsonSchema({
+			type: "object",
+			properties: {
+				title: {
+					type: "string",
+					description: "Short title for the conversation, max 8 words"
+				},
+				summary: {
+					type: "string",
+					description: "1-2 short sentence summary of the conversation. If the conversation direction has changed from the previous summary, reflect the new direction."
+				}
+			},
+			required: ["title", "summary"]
+		}) }),
+		prompt: `${previousContext}\n\n${formatMessagesForConversationSummary(recentMessages)}`
+	});
+	return output;
+}
+/**
+* Generates a title and summary for a conversation using the provided model
+* and writes the result back to D1.
+*
+* Fetches any existing summary first so the model can detect direction changes.
+* Only the last `SUMMARY_CONTEXT_MESSAGES` messages are passed to keep the
+* prompt bounded regardless of total conversation length.
+*
+* Called by `ChatAgentHarness` every `SUMMARY_CONTEXT_MESSAGES` messages after
+* the first turn.
+*/
+async function generateConversationSummary(db, durableObjectName, messages, model) {
+	const { title, summary } = await generateTitleAndSummary(messages, model, (await getConversationSummary(db, durableObjectName))?.summary ?? void 0);
+	await updateConversationSummary(db, durableObjectName, title, summary);
+	return {
+		title,
+		summary
+	};
+}
+//#endregion
+//#region src/server/v1/agent-chat/features/conversations/retention.ts
+const DELETE_CONVERSATION_CALLBACK = "deleteConversationCallback";
+const CONVERSATION_EXPIRED_CLOSE_CODE = 3001;
+const CONVERSATION_EXPIRED_CLOSE_REASON = "Conversation expired due to inactivity.";
+function getConversationRetentionMs(days) {
+	if (typeof days !== "number" || !Number.isFinite(days) || days <= 0) return null;
+	return Math.floor(days * 24 * 60 * 60 * 1e3);
+}
+function getDeleteConversationScheduleIds(schedules) {
+	return schedules.filter((schedule) => schedule.callback === DELETE_CONVERSATION_CALLBACK).map((schedule) => schedule.id);
+}
+//#endregion
+//#region src/server/shared/util/messages.ts
+function filterEphemeralMessages(messages) {
+	return messages.flatMap((message) => {
+		if (message.role !== "assistant" || !message.parts?.length) return [message];
+		const filteredParts = message.parts.filter((part) => !isEphemeralSkillToolPart(part));
+		if (filteredParts.length === 0) return [];
+		return [{
+			...message,
+			parts: filteredParts
+		}];
+	});
+}
+//#endregion
+//#region src/server/v1/agent-chat/features/conversations/rating.ts
+async function rateMessage(db, durableObjectName, messageId, rating, comment) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	await db.prepare(`INSERT INTO message_ratings (message_id, durable_object_name, rating, comment, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT (message_id, durable_object_name) DO UPDATE SET
+        rating = excluded.rating,
+        comment = excluded.comment,
+        updated_at = excluded.updated_at`).bind(messageId, durableObjectName, rating, comment ?? null, now, now).run();
+}
+async function getMessageRatings(db, durableObjectName) {
+	const result = await db.prepare(`SELECT message_id, rating, comment FROM message_ratings WHERE durable_object_name = ?`).bind(durableObjectName).all();
+	return Object.fromEntries(result.results.map((row) => [row.message_id, {
+		rating: row.rating,
+		...row.comment != null ? { comment: row.comment } : {}
+	}]));
+}
+//#endregion
+//#region src/server/v1/agent-chat/ChatAgent.ts
+/**
+* Chat agent for Cloudflare Agents SDK: lazy skill loading, message persistence,
+* compaction, and conversation metadata in D1.
+*
+* Handles CF infrastructure concerns: DO SQLite for loaded skill state,
+* stripping skill meta-tool messages before persistence, and history replay to
+* newly connected clients.
+*
+* Skill loading, compaction, and LLM calls use `buildLLMParams` from
+* `@economic/agents` inside `onChatMessage`.
+*/
+var ChatAgent = class extends AIChatAgent {
+	initialState = {
+		status: "connecting",
+		type: "chat"
+	};
+	/**
+	* Number of days of inactivity before the full conversation is deleted.
+	*
+	* Leave `undefined` to disable automatic retention cleanup.
+	*/
+	conversationRetentionDays;
+	/**
+	* Number of recent messages to keep verbatim when compaction runs.
+	* Older messages beyond this count are summarised into a single system message.
+	* Used as the default when `maxMessagesBeforeCompaction` is not provided to `buildLLMParams`.
+	*
+	* Default is 15.
+	*/
+	maxMessagesBeforeCompaction = 15;
+	clientIp;
+	forwardedFor;
+	/**
+	* The user context for the session.
+	* Define getUserContext to set a user context.
+	*/
+	get userContext() {
+		const { connection } = getCurrentAgent();
+		return (connection?.state)?.userContext ?? {};
+	}
+	/**
+	* Returns the user ID from the durable object name.
+	*/
+	getUserId() {
+		return this.name.split(":")[0];
+	}
+	onStart() {
+		this.setState({
+			...this.initialState,
+			status: "connecting"
+		});
+	}
+	async onClose() {
+		this.setState({
+			type: "chat",
+			status: "disconnected"
+		});
+	}
+	async onConnect(connection, ctx) {
+		this.clientIp = ctx.request.headers.get("CF-Connecting-IP") ?? ctx.request.headers.get("X-Forwarded-For")?.split(",")[0]?.trim();
+		this.forwardedFor = ctx.request.headers.get("X-Forwarded-For") ?? void 0;
+		if (!this.env.AGENT_DB) {
+			console.error("[Agent] Connection rejected: no AGENT_DB bound");
+			connection.close(3e3, "Could not connect to agent");
+			return;
+		}
+		if (!this.env.AGENTS_AUDIT_LOGS) {
+			console.error("[Agent] Connection rejected: no AGENTS_AUDIT_LOGS bound. Audit logs are required.");
+			connection.close(3e3, "Could not connect to agent");
+			return;
+		}
+		if (!this.env.AGENTS_ANALYTICS) console.warn("[Agent] No AGENTS_ANALYTICS bound. Analytics will not be collected.");
+		if (!this.getUserId()) {
+			console.error("[Agent] Connection rejected: name must be in the format userId:uniqueChatId");
+			connection.close(3e3, "Could not connect to agent");
+			return;
+		}
+		if (this.getJwtAuthConfig) {
+			const config = this.getJwtAuthConfig(ctx.request);
+			if (config) {
+				let result;
+				try {
+					result = await verifyJwt(ctx.request, config);
+				} catch (error) {
+					console.error("[Agent] JWT verification error", error);
+					connection.close(4001, "Unauthorized");
+					this.setState({
+						type: "chat",
+						status: "unauthorized"
+					});
+					return;
+				}
+				if (!result.success) {
+					connection.close(result.status === 401 ? 4001 : 4003, result.message);
+					this.setState({
+						type: "chat",
+						status: "unauthorized"
+					});
+					return;
+				}
+			}
+			const token = extractTokenFromConnectRequest(ctx.request);
+			if (token) this._pendingUserContextRequest = this.getUserContext?.(token).then((userContext) => {
+				if (userContext) connection.setState({ userContext });
+			});
+		}
+		this.setState({
+			type: "chat",
+			status: "connected"
+		});
+		return super.onConnect(connection, ctx);
+	}
+	_pendingUserContextRequest;
+	/**
+	* Builds the parameter object for a `streamText` or `generateText` call,
+	* pre-filling `messages`, `activeSkills`, and `fastModel` from this agent instance.
+	*
+	* **Compaction** runs automatically when `fastModel` is set on the class, using
+	* `DEFAULT_MAX_MESSAGES_BEFORE_COMPACTION` (30) as the threshold. Override the
+	* threshold by setting `maxMessagesBeforeCompaction` on the class. Disable compaction
+	* entirely by setting `maxMessagesBeforeCompaction = undefined` explicitly.
+	*/
+	async buildLLMParams(config) {
+		const activeSkills = await getStoredSkills(this.sql.bind(this));
+		const experimental_context = {
+			...config.experimental_context,
+			...config.options?.body,
+			_userContext: this.userContext
+		};
+		const messages = await convertToModelMessages(this.messages);
+		const fastModel = this.getFastModel();
+		const processedMessages = fastModel && this.maxMessagesBeforeCompaction !== void 0 ? await compactIfNeeded(messages, fastModel, this.maxMessagesBeforeCompaction) : messages;
+		return buildLLMParams({
+			...config,
+			activeSkills,
+			messages: processedMessages,
+			experimental_context,
+			experimental_telemetry: {
+				...config.experimental_telemetry,
+				isEnabled: true,
+				tracer: createAgentTracer(this.env.AGENTS_AUDIT_LOGS, this.env.AGENTS_ANALYTICS, {
+					agentName: this.constructor.name,
+					durableObjectName: this.name,
+					actorId: this.getUserId(),
+					...this.clientIp ? { clientIp: this.clientIp } : {},
+					...this.forwardedFor ? { forwardedFor: this.forwardedFor } : {}
+				}),
+				metadata: {
+					agentName: this.constructor.name,
+					version: "v1",
+					durableObjectName: this.name,
+					actorId: this.getUserId(),
+					...this.clientIp ? { clientIp: this.clientIp } : {},
+					...this.forwardedFor ? { forwardedFor: this.forwardedFor } : {},
+					...config.experimental_telemetry?.metadata
+				}
+			}
+		});
+	}
+	async persistMessages(messages, excludeBroadcastIds = [], options) {
+		const filtered = filterEphemeralMessages(messages);
+		await super.persistMessages(filtered, excludeBroadcastIds, options);
+		saveSkillStateFromMessages(this.sql.bind(this), messages);
+		await super.persistMessages(filterEphemeralMessages(messages), excludeBroadcastIds, options);
+	}
+	async onChatResponse(result) {
+		if (result.error) {
+			console.error("[Agent] Chat response error", result.error);
+			return;
+		}
+		recordConversationSummary(this.env.AGENT_DB, this.name, this.messages, this.getFastModel());
+		this.scheduleConversationForAutoDeletion();
+	}
+	@callable({ description: "Rate a message by its id" }) async rateMessage(messageId, rating, comment) {
+		await rateMessage(this.env.AGENT_DB, this.name, messageId, rating, comment);
+	}
+	@callable({ description: "Returns all message ratings for the current conversation" }) async getMessageRatings() {
+		return getMessageRatings(this.env.AGENT_DB, this.name);
+	}
+	@callable({ description: "Returns all conversations for the current user" }) async getConversations() {
+		return getConversations(this.env.AGENT_DB, this.getUserId());
+	}
+	/**
+	* Exports this conversation's persisted message history for the v1 -> v2
+	* migration. Called over DO RPC by the v2 `Assistant` while migrating a
+	* user's chats into facets. `this.messages` is loaded from the
+	* `cf_ai_chat_agent_messages` table when the DO wakes.
+	*
+	* Read-only: does not mutate or delete any state.
+	*/
+	async exportForMigration() {
+		return { messages: this.messages };
+	}
+	@callable({ description: "Delete a conversation by its id" }) async deleteConversation(id) {
+		if (!id.startsWith(`${this.getUserId()}:`)) {
+			console.error("[Agent] Failed to delete conversation: Not owned by current user", {
+				conversationName: id,
+				userId: this.getUserId()
+			});
+			return false;
+		}
+		try {
+			await deleteConversationRow(this.env.AGENT_DB, id);
+		} catch (error) {
+			console.error("[Agent] Failed to delete conversation row", {
+				conversationName: id,
+				error
+			});
+			return false;
+		}
+		await (id === this.name ? this : this.binding.getByName(id)).destroy();
+		return true;
+	}
+	async destroy() {
+		for (const connection of this.getConnections()) try {
+			connection.close(CONVERSATION_EXPIRED_CLOSE_CODE, CONVERSATION_EXPIRED_CLOSE_REASON);
+		} catch (error) {
+			console.error("[Agent] Failed to close expired conversation connection", error);
+		}
+		return super.destroy();
+	}
+	async deleteConversationCallback() {
+		if (await this.deleteConversation(this.name)) console.log("[Agent] Conversation deleted due to inactivity", {
+			conversationName: this.name,
+			retentionDays: this.conversationRetentionDays ?? null
+		});
+	}
+	async scheduleConversationForAutoDeletion() {
+		const retentionMs = getConversationRetentionMs(this.conversationRetentionDays);
+		if (retentionMs === null) return;
+		const scheduleIds = getDeleteConversationScheduleIds(this.getSchedules());
+		await Promise.all(scheduleIds.map((scheduleId) => this.cancelSchedule(scheduleId)));
+		await this.schedule(new Date(Date.now() + retentionMs), DELETE_CONVERSATION_CALLBACK);
+	}
+};
+//#endregion
+//#region src/server/v1/agent-chat/ChatAgentHarness.ts
+var ChatAgentHarness = class extends ChatAgent {
+	get binding() {
+		const className = this.constructor.name;
+		return this.env[className];
+	}
+	conversationRetentionDays = 90;
+	/**
+	* Returns the tools for the agent.
+	* @param ctx - The context object for the agent built from the request body.
+	* @returns The tools for the agent.
+	*/
+	getTools(_ctx) {
+		return {};
+	}
+	/**
+	* Returns the skills for the agent.
+	* @param ctx - The context object for the agent built from the request body.
+	* @returns The skills for the agent.
+	*/
+	getSkills(_ctx) {
+		return [];
+	}
+	async onChatMessage(onFinish, options) {
+		if (this._pendingUserContextRequest) await this._pendingUserContextRequest;
+		const ctx = options?.body;
+		return streamText(await this.buildLLMParams({
+			options,
+			onFinish,
+			model: this.getModel(ctx),
+			system: this.getSystemPrompt(ctx),
+			skills: this.getSkills(ctx),
+			tools: this.getTools(ctx)
+		})).toUIMessageStreamResponse({ sendSources: true });
+	}
+};
+//#endregion
+export { Agent, ChatAgent, ChatAgentHarness, buildLLMParams, routeAgentRequest };