@economic/agents 2.9.1 → 2.10.0

package/dist/index.mjs

@@ -1,9 +1,126 @@
-import { a as extractTokenFromConnectRequest, c as verifyJwt, i as createJwtAuthConfig, n as createAgentTracer, o as getTargetActorId, r as recordFeedbackAnalytics, s as isJwtActorAuthorized, t as routeAgentRequest } from "./route-agent-request-J98VlcOj.mjs";
-import { Agent as Agent$1, callable, getCurrentAgent } from "agents";
+import { Agent as Agent$1, callable, getCurrentAgent, routeAgentRequest as routeAgentRequest$1 } from "agents";
 import { Think, skills } from "@cloudflare/think";
 import { Output, convertToModelMessages, generateText, jsonSchema, pruneMessages, tool as tool$1 } from "ai";
+import { createRemoteJWKSet, decodeJwt, errors, jwtVerify } from "jose";
+import { BasicTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { genericObservability } from "agents/observability";
 import { nanoid } from "nanoid";
 import { createCompactFunction } from "agents/experimental/memory/utils";
+//#region src/server/features/auth/index.ts
+function createJwtAuthConfig(config) {
+	return config;
+}
+const jwksByIssuer = /* @__PURE__ */ new Map();
+/** Returns the actor portion of a top-level or parent-scoped agent name. */
+function getTargetActorId(target) {
+	const rootName = target.parentPath?.[0]?.name ?? target.durableObjectName;
+	const separator = rootName.indexOf(":");
+	return separator === -1 ? rootName : rootName.slice(0, separator);
+}
+/** Checks that verified JWT claims belong to the addressed agent instance. */
+function isJwtActorAuthorized(config, claims, target) {
+	if (typeof config.getActorId !== "function") return false;
+	const authenticatedActorId = config.getActorId(claims);
+	return typeof authenticatedActorId === "string" && authenticatedActorId.length > 0 && authenticatedActorId === getTargetActorId(target);
+}
+function getJwksForIssuer(issuer) {
+	const normalized = issuer.replace(/\/$/, "");
+	let jwks = jwksByIssuer.get(normalized);
+	if (!jwks) {
+		jwks = createRemoteJWKSet(new URL(`${normalized}/.well-known/openid-configuration/jwks`));
+		jwksByIssuer.set(normalized, jwks);
+	}
+	return jwks;
+}
+function isIssuerAllowed(iss, allowed) {
+	return allowed.some((rule) => typeof rule === "string" ? rule === iss : rule.test(iss));
+}
+function extractTokenFromConnectRequest(request) {
+	const authorization = request.headers.get("Authorization");
+	if (authorization) {
+		const match = authorization.match(/^Bearer\s+(.+)$/i);
+		if (match?.[1]) return match[1].trim();
+	}
+	const wsProtocol = request.headers.get("Sec-WebSocket-Protocol");
+	if (wsProtocol) {
+		const parts = wsProtocol.split(",").map((p) => p.trim());
+		const idx = parts.indexOf("bearer");
+		if (idx !== -1 && parts[idx + 1]) return parts[idx + 1];
+	}
+	return null;
+}
+function hasRequiredScopes(tokenScope, required) {
+	if (required.length === 0) return true;
+	if (tokenScope === void 0) return false;
+	const tokens = Array.isArray(tokenScope) ? tokenScope : tokenScope.split(" ").map((s) => s.trim()).filter(Boolean);
+	const granted = new Set(tokens);
+	return required.every((scope) => granted.has(scope));
+}
+/**
+* Verify a JWT from a request and extract claims.
+*
+* Extracts the token from `Authorization: Bearer` header first,
+* then falls back to `Sec-WebSocket-Protocol: bearer, <token>` for WebSocket connections.
+*
+* Expected auth failures (missing/expired token, insufficient scope) return a failure result.
+* Unexpected errors (network issues, malformed requests, untrusted issuers) throw and should
+* be caught and logged by the caller.
+*
+* @param request - The incoming request (from ConnectionContext)
+* @param config - JWT verification configuration
+* @returns Result object with either verified claims or expected auth failure
+* @throws Error for unexpected failures that should be logged
+*/
+async function verifyJwt(request, config) {
+	const token = extractTokenFromConnectRequest(request);
+	if (!token) return {
+		success: false,
+		status: 401,
+		message: "Unauthorized: Missing authentication token"
+	};
+	let unverifiedPayload;
+	try {
+		unverifiedPayload = decodeJwt(token);
+	} catch {
+		throw new Error("Invalid token format");
+	}
+	const iss = typeof unverifiedPayload.iss === "string" ? unverifiedPayload.iss : void 0;
+	if (!iss) throw new Error("Missing issuer claim in token");
+	if (!isIssuerAllowed(iss, config.allowedIssuers)) throw new Error(`Untrusted issuer: ${iss}`);
+	const jwks = getJwksForIssuer(iss);
+	let payload;
+	try {
+		payload = (await jwtVerify(token, jwks, {
+			issuer: iss,
+			audience: config.audience
+		})).payload;
+	} catch (error) {
+		if (error instanceof errors.JWTExpired) return {
+			success: false,
+			status: 401,
+			message: "Unauthorized: Token expired"
+		};
+		if (error instanceof errors.JWTClaimValidationFailed) return {
+			success: false,
+			status: 401,
+			message: "Unauthorized: Token claim validation failed"
+		};
+		if (error instanceof errors.JWSSignatureVerificationFailed || error instanceof errors.JWKSNoMatchingKey) throw new Error("Invalid token signature");
+		throw error;
+	}
+	const requiredScopes = config.requiredScopes ?? [];
+	const scopeClaim = payload.scope;
+	if (!hasRequiredScopes(scopeClaim, requiredScopes)) return {
+		success: false,
+		status: 403,
+		message: "Forbidden: Insufficient scope"
+	};
+	return {
+		success: true,
+		claims: config.getClaims(payload)
+	};
+}
+//#endregion
 //#region src/server/util/agent.ts
 function sendConnectionStatus(connection, status) {
 	connection.send(JSON.stringify({
@@ -253,6 +370,490 @@ Unavailable tools:
 ${restrictions}`;
 }
 //#endregion
+//#region src/server/features/telemetry/skills.ts
+/**
+* Extracts the skill names loaded by an `activate_skill` tool call.
+*
+* v1 `activate_skill` input is `{ skills: string[] }`; v2 uses
+* `{ name: string }`. Return every requested skill name while ignoring empty
+* values so analytics does not group activations under a blank skill.
+*/
+function extractSkillNames(toolName, input) {
+	if (toolName !== "activate_skill" || !input || typeof input !== "object") return [];
+	const { name, skills } = input;
+	if (typeof name === "string" && name) return [name];
+	if (Array.isArray(skills)) return skills.filter((skill) => typeof skill === "string" && skill !== "");
+	return [];
+}
+/**
+* Single-skill variant used where one representative skill name is sufficient
+* (e.g. audit-log attribution and current-skill tracking).
+*/
+function extractSkillName(toolName, input) {
+	return extractSkillNames(toolName, input)[0];
+}
+//#endregion
+//#region src/server/features/telemetry/utils.ts
+function durationMs(duration) {
+	return duration[0] * 1e3 + duration[1] / 1e6;
+}
+function stringAttribute(span, key) {
+	const value = span.attributes[key];
+	return typeof value === "string" ? value : void 0;
+}
+function numberAttribute(span, key) {
+	const value = span.attributes[key];
+	return typeof value === "number" ? value : void 0;
+}
+function parseJson(value) {
+	if (!value) return;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/server/features/telemetry/audit-logs.ts
+function safePathSegment(value, fallback) {
+	return (value || fallback).replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function createAuditLogKey(agentName, durableObjectName) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
+	const id = crypto.randomUUID().slice(0, 8);
+	return [
+		safePathSegment(agentName, "unknown-agent"),
+		safePathSegment(durableObjectName, "unknown-chat"),
+		`${timestamp}-${id}.json`
+	].join("/");
+}
+function textFromContent(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((part) => {
+		if (!part || typeof part !== "object") return "";
+		const value = part.text;
+		return typeof value === "string" ? value : "";
+	}).filter(Boolean).join("\n");
+	return "";
+}
+function extractPrompt(messages) {
+	const firstUserMessage = messages.find((message) => message.role === "user");
+	return firstUserMessage ? textFromContent(firstUserMessage.content) : "";
+}
+function promptCharCount(messages) {
+	const firstUserMessage = messages.find((message) => message.role === "user");
+	return firstUserMessage ? textFromContent(firstUserMessage.content).length : 0;
+}
+function extractTools(messages) {
+	const tools = [];
+	for (const message of messages) {
+		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+		for (const part of message.content) {
+			if (!part || typeof part !== "object") continue;
+			const record = part;
+			if (record.type !== "tool_use") continue;
+			tools.push({
+				name: typeof record.name === "string" ? record.name : void 0,
+				input: record.input,
+				status: "success"
+			});
+		}
+	}
+	return tools;
+}
+function pushToolCall(map, key, toolCall) {
+	const existing = map.get(key);
+	if (existing) existing.push(toolCall);
+	else map.set(key, [toolCall]);
+}
+/**
+* Stores the last ai.streamText.doStream span per chat.
+* Its ai.prompt.messages contains the full chat history including all
+* intermediate tool_use + tool_result turns from the agentic loop.
+*/
+const lastDoStreamByChat = /* @__PURE__ */ new Map();
+const toolCallsByParentSpan = /* @__PURE__ */ new Map();
+const toolCallsByChat = /* @__PURE__ */ new Map();
+const pendingToolCalls = [];
+const currentSkillByChat = /* @__PURE__ */ new Map();
+function rememberToolCall(span) {
+	const parentSpanId = span.parentSpanContext?.spanId;
+	const toolName = stringAttribute(span, "ai.toolCall.name");
+	const input = parseJson(stringAttribute(span, "ai.toolCall.args"));
+	const toolCall = {
+		name: toolName,
+		input,
+		status: span.status.code === 0 ? "success" : "error",
+		skillName: extractSkillName(toolName, input)
+	};
+	if (parentSpanId) pushToolCall(toolCallsByParentSpan, parentSpanId, toolCall);
+	pendingToolCalls.push(toolCall);
+}
+function attachToolCallsToChat(span, durableObjectName) {
+	const spanId = span.spanContext().spanId;
+	const toolCalls = toolCallsByParentSpan.get(spanId) ?? pendingToolCalls.splice(0);
+	if (!toolCalls.length) return;
+	toolCallsByParentSpan.delete(spanId);
+	const currentSkill = currentSkillByChat.get(durableObjectName);
+	const attributedToolCalls = toolCalls.map((toolCall) => {
+		const skillName = toolCall.skillName ?? currentSkill;
+		if (toolCall.skillName) currentSkillByChat.set(durableObjectName, toolCall.skillName);
+		return {
+			...toolCall,
+			...skillName ? { skillName } : {}
+		};
+	});
+	toolCallsByChat.set(durableObjectName, [...toolCallsByChat.get(durableObjectName) ?? [], ...attributedToolCalls]);
+}
+function buildAuditLog(span, context) {
+	const lastDoStream = lastDoStreamByChat.get(context.durableObjectName);
+	lastDoStreamByChat.delete(context.durableObjectName);
+	const promptMessages = parseJson(stringAttribute(lastDoStream ?? span, "ai.prompt.messages"));
+	const fallbackPrompt = parseJson(stringAttribute(span, "ai.prompt"));
+	const inputMessages = promptMessages ?? fallbackPrompt?.messages ?? [];
+	const spanToolCalls = toolCallsByChat.get(context.durableObjectName) ?? [];
+	toolCallsByChat.delete(context.durableObjectName);
+	return {
+		id: createAuditLogKey(context.agentName, context.durableObjectName),
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		durableObjectName: context.durableObjectName,
+		agent: {
+			name: context.agentName,
+			llm: {
+				model: stringAttribute(span, "ai.model.id"),
+				provider: stringAttribute(span, "ai.model.provider")
+			}
+		},
+		actor: {
+			id: context.actorId,
+			ip: {
+				client: context.clientIp ?? context.forwardedFor?.split(",").map((ip) => ip.trim()).filter(Boolean)[0],
+				forwardedFor: context.forwardedFor?.split(",").map((ip) => ip.trim()).filter(Boolean) ?? []
+			}
+		},
+		prompt: extractPrompt(inputMessages),
+		response: stringAttribute(span, "ai.response.text") ?? "",
+		status: span.status.code === 0 ? "success" : "error",
+		tools: [...extractTools(inputMessages), ...spanToolCalls]
+	};
+}
+function rememberDoStream(span, durableObjectName) {
+	lastDoStreamByChat.set(durableObjectName, span);
+}
+async function handleAuditSpan(span, auditLogs, context) {
+	const auditLog = buildAuditLog(span, context);
+	if (!auditLogs) return;
+	await auditLogs.put(auditLog.id, JSON.stringify(auditLog, null, 2), { httpMetadata: { contentType: "application/json" } });
+	console.log("[AuditLog] Created", auditLog.id);
+}
+//#endregion
+//#region src/server/features/telemetry/analytics.ts
+const emittedToolCallIds = /* @__PURE__ */ new Set();
+function safeJsonString(value) {
+	if (value === void 0) return void 0;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return;
+	}
+}
+function writeAnalyticsDatapoint(analytics, dataPoint) {
+	if (!analytics) return;
+	try {
+		analytics.writeDataPoint(dataPoint);
+	} catch (error) {
+		console.error("[Agent] Failed to write analytics datapoint", error);
+	}
+}
+/**
+* Writes a message-feedback rating to Analytics Engine so sentiment can be
+* aggregated across all chats without fanning out to every chat DO.
+*
+* Emitted on every rating change; the dashboard takes the latest rating per
+* `messageId` (blob4) so re-rates and clears are idempotent.
+*/
+function recordFeedbackAnalytics(analytics, context, messageId, rating) {
+	writeAnalyticsDatapoint(analytics, {
+		indexes: [context.actorId],
+		blobs: [
+			"feedback",
+			context.agentName,
+			context.durableObjectName,
+			messageId
+		],
+		doubles: [rating]
+	});
+}
+function recordPromptReceivedAnalytics(analytics, context, messages, continuation) {
+	if (!analytics) return;
+	writeAnalyticsDatapoint(analytics, {
+		indexes: [context.actorId],
+		blobs: [
+			"prompt_received",
+			context.agentName,
+			context.durableObjectName,
+			String(continuation)
+		],
+		doubles: [safeJsonString(messages)?.length ?? 0]
+	});
+}
+function recordTurnCompletedAnalytics(analytics, context, requestId, status, continuation, response) {
+	if (!analytics) return;
+	writeAnalyticsDatapoint(analytics, {
+		indexes: [context.actorId],
+		blobs: [
+			"turn_completed",
+			context.agentName,
+			context.durableObjectName,
+			requestId,
+			status,
+			String(continuation)
+		],
+		doubles: [safeJsonString(response)?.length ?? 0]
+	});
+}
+function handleAnalyticsSpan(span, analytics, context) {
+	if (span.name === "ai.streamText.doStream") {
+		const promptMessages = parseJson(stringAttribute(span, "ai.prompt.messages"));
+		const responseText = stringAttribute(span, "ai.response.text") ?? "";
+		const responseToolCalls = parseJson(stringAttribute(span, "ai.response.toolCalls"));
+		writeAnalyticsDatapoint(analytics, {
+			indexes: [context.actorId],
+			blobs: [
+				"llm_call",
+				context.agentName,
+				context.durableObjectName,
+				stringAttribute(span, "ai.model.id") ?? "",
+				stringAttribute(span, "ai.model.provider") ?? "",
+				stringAttribute(span, "ai.response.finishReason") ?? ""
+			],
+			doubles: [
+				numberAttribute(span, "ai.usage.inputTokens") ?? 0,
+				numberAttribute(span, "ai.usage.outputTokens") ?? 0,
+				numberAttribute(span, "ai.usage.totalTokens") ?? 0,
+				numberAttribute(span, "ai.usage.inputTokenDetails.cacheReadTokens") ?? 0,
+				numberAttribute(span, "ai.usage.inputTokenDetails.cacheWriteTokens") ?? 0,
+				durationMs(span.duration),
+				promptCharCount(promptMessages ?? []),
+				responseText.length
+			]
+		});
+		if (Array.isArray(responseToolCalls)) for (const value of responseToolCalls) {
+			if (!value || typeof value !== "object") continue;
+			const toolCall = value;
+			const toolCallId = typeof toolCall.toolCallId === "string" ? toolCall.toolCallId : void 0;
+			if (toolCallId && emittedToolCallIds.has(toolCallId)) continue;
+			const toolName = typeof toolCall.toolName === "string" ? toolCall.toolName : void 0;
+			if (!toolName) continue;
+			const input = toolCall.input;
+			const argsRaw = safeJsonString(input);
+			const success = span.status.code === 0;
+			const activatedSkills = extractSkillNames(toolName, input);
+			const skillNames = activatedSkills.length ? activatedSkills : [currentSkillByChat.get(context.durableObjectName) ?? ""];
+			if (toolCallId) emittedToolCallIds.add(toolCallId);
+			for (const skillName of skillNames) writeAnalyticsDatapoint(analytics, {
+				indexes: [context.actorId],
+				blobs: [
+					"tool_call",
+					context.agentName,
+					context.durableObjectName,
+					toolName,
+					skillName,
+					success ? "success" : "error"
+				],
+				doubles: [
+					0,
+					success ? 1 : 0,
+					argsRaw?.length ?? 0,
+					0,
+					0,
+					0,
+					0,
+					0
+				]
+			});
+		}
+		return;
+	}
+	if (span.name === "ai.toolCall") {
+		const toolName = stringAttribute(span, "ai.toolCall.name");
+		const toolCallId = stringAttribute(span, "ai.toolCall.id");
+		if (toolCallId && emittedToolCallIds.has(toolCallId)) return;
+		if (toolCallId) emittedToolCallIds.add(toolCallId);
+		const argsRaw = stringAttribute(span, "ai.toolCall.args");
+		const toolInput = parseJson(argsRaw);
+		const success = span.status.code === 0;
+		const duration = durationMs(span.duration);
+		const argsSize = argsRaw?.length ?? 0;
+		const resultSize = stringAttribute(span, "ai.toolCall.result")?.length ?? 0;
+		const activatedSkills = extractSkillNames(toolName, toolInput);
+		const skillNames = activatedSkills.length ? activatedSkills : [currentSkillByChat.get(context.durableObjectName) ?? ""];
+		for (const skillName of skillNames) writeAnalyticsDatapoint(analytics, {
+			indexes: [context.actorId],
+			blobs: [
+				"tool_call",
+				context.agentName,
+				context.durableObjectName,
+				toolName ?? "",
+				skillName,
+				success ? "success" : "error"
+			],
+			doubles: [
+				duration,
+				success ? 1 : 0,
+				argsSize,
+				resultSize,
+				0,
+				0,
+				0,
+				0
+			]
+		});
+	}
+}
+//#endregion
+//#region src/server/features/observability/index.ts
+const measuredEvents = /* @__PURE__ */ new Set(["chat:turn:finish"]);
+const warningEvents = /* @__PURE__ */ new Set([
+	"schedule:duplicate_warning",
+	"alarm:memory_limit_reset",
+	"fiber:run:interrupted",
+	"chat:onstart:degraded",
+	"chat:stream:stalled",
+	"agent_tool:recovery:deadline",
+	"agent_tool:detached:live_count_warning"
+]);
+function writeOperationalLog(record, logger = console) {
+	try {
+		const message = JSON.stringify(record);
+		if (record.level === "error") logger.error(message);
+		else if (record.level === "warn") logger.warn(message);
+		else logger.log(message);
+	} catch {}
+}
+function isFailure(event) {
+	return event.type.endsWith("error") || event.type.endsWith("failed") || event.type.endsWith("exhausted") || "error" in event.payload && Boolean(event.payload.error);
+}
+/**
+* Preserves Cloudflare Agents diagnostics while mirroring the operational
+* subset into structured Worker logs for Logpush destinations.
+*/
+function createWorkerObservability(options = {}) {
+	const diagnostics = options.diagnostics ?? genericObservability;
+	const logger = options.logger ?? console;
+	return { emit(event) {
+		diagnostics.emit(event);
+		const failed = isFailure(event);
+		if (!failed && !warningEvents.has(event.type) && !measuredEvents.has(event.type)) return;
+		const identity = options.getIdentity?.();
+		const attributes = Object.fromEntries(Object.entries(event.payload).filter(([key]) => key !== "error"));
+		writeOperationalLog({
+			source: "@economic/agents",
+			event: event.type,
+			level: failed ? "error" : warningEvents.has(event.type) ? "warn" : "info",
+			timestamp: event.timestamp,
+			agentName: identity?.agentName ?? event.agent,
+			agentClass: identity?.agentClass ?? event.agent,
+			durableObjectName: event.name,
+			attributes
+		}, logger);
+	} };
+}
+//#endregion
+//#region src/server/features/observability/ai.ts
+const AI_MODEL_SPANS = /* @__PURE__ */ new Set(["ai.generateText.doGenerate", "ai.streamText.doStream"]);
+function failed(span) {
+	return span.status.code === 2 || stringAttribute(span, "ai.response.finishReason") === "error";
+}
+function baseRecord(span, context) {
+	return {
+		source: "@economic/agents",
+		level: failed(span) ? "error" : "info",
+		timestamp: Date.now(),
+		agentName: context.agentName,
+		agentClass: context.agentClass,
+		durableObjectName: context.durableObjectName
+	};
+}
+function operationalLogFromAISpan(span, context) {
+	if (AI_MODEL_SPANS.has(span.name)) {
+		const isFailure = failed(span);
+		return {
+			...baseRecord(span, context),
+			event: isFailure ? "agent.llm.failed" : "agent.llm.completed",
+			attributes: {
+				operation: span.name,
+				provider: stringAttribute(span, "ai.model.provider"),
+				model: stringAttribute(span, "ai.model.id"),
+				finishReason: stringAttribute(span, "ai.response.finishReason"),
+				durationMs: durationMs(span.duration),
+				timeToFirstChunkMs: numberAttribute(span, "ai.response.msToFirstChunk"),
+				inputTokens: numberAttribute(span, "ai.usage.inputTokens"),
+				outputTokens: numberAttribute(span, "ai.usage.outputTokens"),
+				totalTokens: numberAttribute(span, "ai.usage.totalTokens"),
+				cachedInputTokens: numberAttribute(span, "ai.usage.cachedInputTokens"),
+				cacheWriteTokens: numberAttribute(span, "ai.usage.inputTokenDetails.cacheWriteTokens"),
+				reasoningTokens: numberAttribute(span, "ai.usage.reasoningTokens")
+			}
+		};
+	}
+	if (span.name === "ai.toolCall") {
+		const isFailure = failed(span);
+		return {
+			...baseRecord(span, context),
+			event: isFailure ? "agent.tool.failed" : "agent.tool.completed",
+			attributes: {
+				toolName: stringAttribute(span, "ai.toolCall.name"),
+				durationMs: durationMs(span.duration)
+			}
+		};
+	}
+}
+function logAISpan(span, context, logger = console) {
+	const record = operationalLogFromAISpan(span, context);
+	if (record) writeOperationalLog(record, logger);
+}
+//#endregion
+//#region src/server/features/telemetry/index.ts
+var AgentSpanExporter = class {
+	auditLogs;
+	analytics;
+	context;
+	constructor(auditLogs, analytics, context) {
+		this.auditLogs = auditLogs;
+		this.analytics = analytics;
+		this.context = context;
+	}
+	export(spans, resultCallback) {
+		(async () => {
+			try {
+				for (const span of spans) {
+					logAISpan(span, this.context);
+					if (span.name === "ai.streamText.doStream") {
+						rememberDoStream(span, this.context.durableObjectName);
+						attachToolCallsToChat(span, this.context.durableObjectName);
+						handleAnalyticsSpan(span, this.analytics, this.context);
+					} else if (span.name === "ai.streamText") await handleAuditSpan(span, this.auditLogs, this.context);
+					else if (span.name === "ai.toolCall") {
+						rememberToolCall(span);
+						handleAnalyticsSpan(span, this.analytics, this.context);
+					}
+				}
+				resultCallback({ code: 0 });
+			} catch (error) {
+				resultCallback({
+					code: 1,
+					error: error instanceof Error ? error : new Error(String(error))
+				});
+			}
+		})();
+	}
+	async shutdown() {}
+};
+function createAgentTracer(auditLogs, analytics, context) {
+	return new BasicTracerProvider({ spanProcessors: [new SimpleSpanProcessor(new AgentSpanExporter(auditLogs, analytics, context))] }).getTracer("@economic/agents");
+}
+//#endregion
 //#region src/server/features/registry.ts
 /**
 * Registers a top-level DO in the global registry.
@@ -441,6 +1042,11 @@ var Agent = class extends Think {
 	* `returned.tools` into your own `TurnConfig.tools` if you return tools.
 	*/
 	async beforeTurn(ctx) {
+		recordPromptReceivedAnalytics(this.env.AGENTS_ANALYTICS, {
+			agentName: this.getTelemetryAgentName(),
+			durableObjectName: this.name,
+			actorId: this.getTelemetryActorId()
+		}, ctx.messages, ctx.continuation);
 		this.registerInstanceActivity();
 		const body = await this._applyTokenExchange(ctx.body);
 		this._turn.context = this.getToolContextForCurrentTurn(body);
@@ -460,6 +1066,7 @@ var Agent = class extends Think {
 				isEnabled: true,
 				tracer: createAgentTracer(this.env.AGENTS_AUDIT_LOGS, this.env.AGENTS_ANALYTICS, {
 					agentName: this.getTelemetryAgentName(),
+					agentClass: this.constructor.name,
 					durableObjectName: this.name,
 					actorId: this.getTelemetryActorId(),
 					clientIp: this.clientIp,
@@ -800,6 +1407,10 @@ var Agent = class extends Think {
 			console.error("[Agent] Failed to update agent_registry activity", error);
 		}
 	}
+	observability = createWorkerObservability({ getIdentity: () => ({
+		agentName: this.getTelemetryAgentName(),
+		agentClass: this.constructor.name
+	}) });
 	/**
 	* Resolves the analytics/telemetry agent name to the entry-point agent: the
 	* top-level DO registered in the `agent` catalog table.
@@ -893,11 +1504,14 @@ async function getChats(sql) {
 	return sql`SELECT * FROM chats ORDER BY updated_at DESC`;
 }
 function recordChatFeedback(sql, durableObjectName, messageId, rating, dateTime = Date.now()) {
-	sql`INSERT INTO chat_message_feedback (chat_id, message_id, rating, updated_at)
-    VALUES (${durableObjectName}, ${messageId}, ${rating}, ${dateTime})
-    ON CONFLICT (chat_id, message_id) DO UPDATE SET
-      rating = excluded.rating,
-      updated_at = excluded.updated_at`;
+	if (!getChat(sql, durableObjectName)) throw new Error(`Chat not found: ${durableObjectName}`);
+	if (rating === 0) sql`DELETE FROM chat_message_feedback
+      WHERE chat_id = ${durableObjectName} AND message_id = ${messageId}`;
+	else sql`INSERT INTO chat_message_feedback (chat_id, message_id, rating, updated_at)
+      VALUES (${durableObjectName}, ${messageId}, ${rating}, ${dateTime})
+      ON CONFLICT (chat_id, message_id) DO UPDATE SET
+        rating = excluded.rating,
+        updated_at = excluded.updated_at`;
 	const positiveRows = sql`SELECT COUNT(*) AS count
     FROM chat_message_feedback
     WHERE chat_id = ${durableObjectName} AND rating > 0`;
@@ -927,7 +1541,7 @@ async function summariseChatWithAI(sql, durableObjectName, messages, model) {
     The title should be a short title for the chat, max 8-10 words.
     The summary should be a short 1-2 sentence summary of the chat.
     The summary should reflect the direction of the chat.`;
-	if (chat) systemPrompt += `${systemPrompt}\n\nThe previous summary: ${chat.summary}`;
+	if (chat) systemPrompt += `\n\nThe previous summary: ${chat.summary}`;
 	try {
 		const { output: { title, summary } } = await generateText({
 			model,
@@ -1287,6 +1901,10 @@ var Assistant = class extends Agent$1 {
 			console.error("[Assistant] Failed to update agent_registry activity", error);
 		}
 	}
+	observability = createWorkerObservability({ getIdentity: () => ({
+		agentName: this.constructor.name,
+		agentClass: this.constructor.name
+	}) });
 };
 //#endregion
 //#region src/server/features/messages.ts
@@ -1322,6 +1940,10 @@ function ensureFeedbackTableExists(sql) {
 */
 function submitMessageFeedback(sql, messageId, rating, comment, now = /* @__PURE__ */ new Date()) {
 	try {
+		if (rating === 0) {
+			sql`DELETE FROM assistant_messages_feedback WHERE message_id = ${messageId}`;
+			return;
+		}
 		sql`INSERT INTO assistant_messages_feedback (message_id, rating, comment, created_at, updated_at)
         VALUES (${messageId}, ${rating}, ${comment ?? null}, ${now.getTime()}, ${now.getTime()})
         ON CONFLICT (message_id) DO UPDATE SET
@@ -1339,7 +1961,9 @@ function submitMessageFeedback(sql, messageId, rating, comment, now = /* @__PURE
 */
 function getMessageFeedback(sql) {
 	try {
-		const feedback = sql`SELECT message_id, rating, comment, created_at, updated_at FROM assistant_messages_feedback`;
+		const feedback = sql`SELECT message_id, rating, comment, created_at, updated_at
+      FROM assistant_messages_feedback
+      WHERE rating IN (1, -1)`;
 		return Object.fromEntries(feedback.map((row) => [row.message_id, row]));
 	} catch {
 		return {};
@@ -1501,14 +2125,19 @@ var ChatAgent = class extends Agent {
 		if (parent?.registerChat) await parent.registerChat(this.name);
 		return super.beforeTurn(ctx);
 	}
-	async onChatResponse(_result) {
+	async onChatResponse(result) {
+		recordTurnCompletedAnalytics(this.env.AGENTS_ANALYTICS, {
+			agentName: this.getTelemetryAgentName(),
+			durableObjectName: this.name,
+			actorId: this.getTelemetryActorId()
+		}, result.requestId, result.status, result.continuation, result.message.parts);
 		const parent = await this.getParentAgent();
 		if (parent?.recordChatTurn) await parent.recordChatTurn(this.name, this.messages);
 	}
 	/**
 	* Submit feedback for a message by its id.
 	* @param messageId - The id of the message to give feedback on.
-	* @param rating - The rating to give the message. 1 = thumbs up, -1 = thumbs down.
+	* @param rating - The rating to give the message. 1 = thumbs up, -1 = thumbs down, 0 = clear.
 	* @returns The message id and the rating.
 	*/
 	async submitMessageFeedback(messageId, rating, comment) {
@@ -1566,6 +2195,19 @@ function skill(definition) {
 	};
 }
 //#endregion
+//#region src/server/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/index.ts
 function getCurrentToolContext() {
 	return getCurrentAgent().agent._lastBody;