autotel-cloudflare 3.0.0 → 4.0.0

package/dist/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","names":[],"sources":["../src/agents/types.ts","../src/agents/otel-observability.ts"],"mappings":";;;;;;;UAUiB,cAAA,mCAEC,MAAA,oBAA0B,MAAA;EAE1C,IAAA,EAAM,CAAA;EAMG;EAJT,EAAA;EAIyB;EAFzB,cAAA;EAPA;EASA,OAAA,EAAS,OAAA,GAAU,MAAA;EARH;EAUhB,SAAA;AAAA;;;;KAMU,uBAAA,GACR,cAAA,iBAA+B,MAAA,qBAC/B,cAAA;EAGI,MAAA;EACA,SAAA;AAAA,KAGJ,cAAA,yCAAuD,MAAA,qBACvD,cAAA,oBACA,cAAA;EAGI,QAAA;EACA,EAAA;AAAA,KAGJ,cAAA,cACA,cAAA;EAGI,YAAA;AAAA;;;;KAOI,qBAAA,GACR,cAAA;EAA0C,QAAA;AAAA,KAC1C,cAAA;EAEI,GAAA;EAAa,SAAA;EAAmB,KAAA;EAAe,KAAA;AAAA,KAEnD,cAAA;EAGI,QAAA;EACA,OAAA;EACA,QAAA;AAAA,KAGJ,cAAA,wBAAsC,MAAA;;;;KAK9B,kBAAA,GAAqB,uBAAA,GAA0B,qBAAqB;;;;UAK/D,aAAA;EAlCb;;;AAGgB;AAOpB;EA8BE,IAAA,CAAK,KAAA,EAAO,kBAAA,EAAoB,GAAA,GAAM,kBAAkB;AAAA;;;;UAMzC,2BAAA;EAtBb;;;;EA2BF,QAAA;EAvCE;;;;EA6CF,aAAA;EAzCE;;;;EA+CF,QAAA;EAvCwC;;AAAM;AAKhD;EAwCE,iBAAA;;;AAxC8E;AAKhF;EAyCE,aAAA;;;;;EAMA,cAAA;EAzCsC;;;EA8CtC,kBAAA,IAAsB,KAAA,EAAO,kBAAA,KAAuB,UAAA;EAxCrC;;;EA6Cf,iBAAA,IAAqB,KAAA,EAAO,kBAAA;AAAA;;;;KAMlB,uBAAA,GAA0B,mBAAA;EAxCpC;;;EA4CA,MAAA,GAAS,2BAA2B;AAAA;;;;UAMrB,mBAAA;EACf,kBAAA;EACA,gBAAA;EACA,kBAAA;EACA,qBAAA;EACA,yBAAA;EACA,mBAAA;EACA,qBAAA;EACA,qBAAA;EACA,eAAA;EACA,qBAAA;EACA,iBAAA;AAAA;;;;;AA/IS;AAMX;;;cCwSa,iBAAA,YAA6B,aAAA;EAAA,QAChC,MAAA;EAAA,QACA,OAAA;EAAA,QACA,WAAA;cAEI,MAAA,EAAQ,uBAAA;EDnSlB;;;EAAA,QC6SM,UAAA;EDpSQ;;;;;EC+ShB,IAAA,CAAK,KAAA,EAAO,kBAAA,EAAoB,GAAA,GAAM,kBAAA;AAAA;;;;;;;;;;;AD5SpB;AAOpB;;;;;iBC0WgB,uBAAA,CAAwB,MAAA,EAAQ,uBAAA,GAA0B,iBAAiB;;;;;;;;;;;;;;;;;;;AD5V3C;AAKhD;iBC+WgB,8BAAA,CACd,GAAA,EAAK,MAAA,mBACL,OAAA,GAAU,2BAAA,GACT,iBAAA"}
+{"version":3,"file":"agents.d.ts","names":[],"sources":["../src/agents/base.ts","../src/agents/agent.ts","../src/agents/mcp.ts","../src/agents/observability.ts","../src/agents/types.ts","../src/agents/otel-observability.ts"],"mappings":"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"}

package/dist/agents.js

@@ -1,44 +1,15 @@
 import { WorkerTracer, WorkerTracerProvider, createInitialiser } from "autotel-edge";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { agentContextFromSpan, recordHumanApproval } from "autotel-genai/agent";
 
 //#region src/agents/otel-observability.ts
 /**
 * OpenTelemetry-based Observability implementation for Cloudflare Agents SDK
 *
 * Converts Agent events into OpenTelemetry spans for distributed tracing.
-*
-* @example
-* ```typescript
-* import { Agent } from 'agents'
-* import { createOtelObservability } from 'autotel-cloudflare/agents'
-*
-* class MyAgent extends Agent<Env> {
-*   observability = createOtelObservability({
-*     service: { name: 'my-agent' },
-*     exporter: { url: env.OTLP_ENDPOINT }
-*   })
-*
-*   @callable()
-*   async doSomething() {
-*     // This RPC call will be automatically traced
-*     return 'done'
-*   }
-* }
-* ```
-*/
-/**
-* Map of active spans keyed by event ID
-* Used to correlate start/end events
-*/
-const activeSpans = /* @__PURE__ */ new Map();
-/**
-* Whether the provider has been initialized
 */
 let providerInitialized = false;
-/**
-* Initialize the tracer provider for Agents
-*/
 function initProvider(config) {
 	if (providerInitialized) return;
 	const resource = resourceFromAttributes({
@@ -55,128 +26,221 @@ function initProvider(config) {
 	trace.getTracer("autotel-cloudflare/agents").setHeadSampler(config.sampling.headSampler);
 	providerInitialized = true;
 }
-/**
-* Get default span name for an event
-*/
+function classifyEvent(type) {
+	if (type.startsWith("mcp:")) return "mcp";
+	if (type.startsWith("workflow:")) return "workflow";
+	if (type.startsWith("fiber:")) return "fiber";
+	if (type.startsWith("agent_tool:")) return "agentTool";
+	if (type.startsWith("chat:transcript:")) return "transcript";
+	if (type.startsWith("chat:")) return "chat";
+	if (type.startsWith("submission:")) return "submission";
+	if (type.startsWith("queue:")) return "queue";
+	if (type.startsWith("schedule:")) return "schedule";
+	if (type.startsWith("message:") || type.startsWith("tool:") || type === "rpc:error") return "message";
+	if (type === "rpc") return "rpc";
+	if (type.startsWith("state:")) return "state";
+	if (type.startsWith("email:")) return "email";
+	if (type === "connect" || type === "disconnect" || type === "destroy") return "lifecycle";
+	return "message";
+}
+function shouldTraceEvent(event, options) {
+	const merged = {
+		traceRpc: true,
+		traceSchedule: true,
+		traceQueue: true,
+		traceSubmissions: true,
+		traceMcp: true,
+		traceStateUpdates: false,
+		traceMessages: true,
+		traceLifecycle: true,
+		traceChat: true,
+		traceTranscripts: true,
+		traceFibers: true,
+		traceToolRecovery: true,
+		traceWorkflow: true,
+		traceEmail: true,
+		...options
+	};
+	switch (classifyEvent(event.type)) {
+		case "rpc": return merged.traceRpc;
+		case "schedule": return merged.traceSchedule;
+		case "queue": return merged.traceQueue;
+		case "submission": return merged.traceSubmissions;
+		case "mcp": return merged.traceMcp;
+		case "state": return merged.traceStateUpdates;
+		case "message": return merged.traceMessages;
+		case "lifecycle": return merged.traceLifecycle;
+		case "chat": return merged.traceChat;
+		case "transcript": return merged.traceTranscripts;
+		case "fiber": return merged.traceFibers;
+		case "agentTool": return merged.traceToolRecovery;
+		case "workflow": return merged.traceWorkflow;
+		case "email": return merged.traceEmail;
+	}
+}
+function formatTypeSegment(value) {
+	return value.replaceAll(/[:_]/g, ".");
+}
+function getPayloadName(payload, ...keys) {
+	for (const key of keys) {
+		const value = payload[key];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+}
 function getDefaultSpanName(event) {
+	const payload = event.payload;
 	switch (event.type) {
-		case "rpc": return `agent.rpc ${event.payload.method}`;
-		case "schedule:create": return `agent.schedule.create ${event.payload.callback}`;
-		case "schedule:execute": return `agent.schedule.execute ${event.payload.callback}`;
-		case "schedule:cancel": return `agent.schedule.cancel ${event.payload.callback}`;
-		case "connect": return `agent.connect`;
-		case "destroy": return `agent.destroy`;
-		case "state:update": return `agent.state.update`;
-		case "message:request": return `agent.message.request`;
-		case "message:response": return `agent.message.response`;
-		case "message:clear": return `agent.message.clear`;
-		case "mcp:client:preconnect": return `mcp.preconnect ${event.payload.serverId}`;
-		case "mcp:client:connect": return `mcp.connect ${event.payload.url}`;
-		case "mcp:client:authorize": return `mcp.authorize ${event.payload.serverId}`;
-		case "mcp:client:discover": return `mcp.discover`;
-		default: return `agent.${event.type}`;
+		case "rpc":
+		case "rpc:error": return `agent.rpc ${payload.method}`;
+		case "schedule:create":
+		case "schedule:execute":
+		case "schedule:cancel":
+		case "schedule:retry":
+		case "schedule:error":
+		case "schedule:duplicate_warning": return `agent.${formatTypeSegment(event.type)} ${getPayloadName(payload, "callback") ?? "unknown"}`;
+		case "queue:create":
+		case "queue:retry":
+		case "queue:error": return `agent.${formatTypeSegment(event.type)} ${getPayloadName(payload, "callback") ?? "unknown"}`;
+		case "submission:create":
+		case "submission:status":
+		case "submission:error": return `agent.${formatTypeSegment(event.type)} ${getPayloadName(payload, "submissionId") ?? "unknown"}`;
+		case "connect":
+		case "disconnect": return `agent.${event.type} ${getPayloadName(payload, "connectionId") ?? "unknown"}`;
+		case "mcp:client:preconnect": return `mcp.client.preconnect ${getPayloadName(payload, "serverId") ?? "unknown"}`;
+		case "mcp:client:authorize": return `mcp.client.authorize ${getPayloadName(payload, "serverId") ?? "unknown"}`;
+		case "mcp:client:connect":
+		case "mcp:client:discover":
+		case "mcp:client:close": return `mcp.client.${formatTypeSegment(event.type).split(".").slice(-1)[0]} ${getPayloadName(payload, "url", "capability", "state") ?? "unknown"}`;
+		case "workflow:start":
+		case "workflow:event":
+		case "workflow:approved":
+		case "workflow:rejected":
+		case "workflow:terminated":
+		case "workflow:paused":
+		case "workflow:resumed":
+		case "workflow:restarted": return `agent.${formatTypeSegment(event.type)} ${getPayloadName(payload, "workflowName", "workflowId", "eventType") ?? "unknown"}`;
+		case "email:receive":
+		case "email:reply":
+		case "email:send": return `agent.${formatTypeSegment(event.type)} ${getPayloadName(payload, "subject") ?? "message"}`;
+		case "destroy": return "agent.destroy";
+		default: return `agent.${formatTypeSegment(event.type)}`;
 	}
 }
-/**
-* Get default attributes for an event
-*/
+function isPrimitiveAttributeValue(value) {
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
+	if (!Array.isArray(value)) return false;
+	return value.every((entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean");
+}
+function setIfPresent(attrs, key, value) {
+	if (value === void 0 || value === null) return;
+	if (isPrimitiveAttributeValue(value)) attrs[key] = value;
+}
 function getDefaultAttributes(event) {
-	const attrs = {
-		"agent.event.type": event.type,
-		"agent.event.id": event.id
-	};
+	const attrs = { "agent.event.type": event.type };
+	setIfPresent(attrs, "agent.event.id", event.id);
+	setIfPresent(attrs, "agent.display_message", event.displayMessage);
+	setIfPresent(attrs, "agent.class", event.agent);
+	setIfPresent(attrs, "agent.instance.name", event.name);
+	setIfPresent(attrs, "gen_ai.agent.name", event.agent);
 	switch (event.type) {
 		case "rpc":
 			attrs["agent.rpc.method"] = event.payload.method;
-			if (event.payload.streaming !== void 0) attrs["agent.rpc.streaming"] = event.payload.streaming;
+			setIfPresent(attrs, "agent.rpc.streaming", event.payload.streaming);
+			break;
+		case "rpc:error":
+			attrs["agent.rpc.method"] = event.payload.method;
 			break;
 		case "schedule:create":
 		case "schedule:execute":
 		case "schedule:cancel":
-			attrs["agent.schedule.callback"] = event.payload.callback;
-			attrs["agent.schedule.id"] = event.payload.id;
+		case "schedule:retry":
+		case "schedule:error":
+		case "queue:create":
+		case "queue:retry":
+		case "queue:error":
+			setIfPresent(attrs, "agent.schedule.callback", event.payload.callback);
+			setIfPresent(attrs, "agent.schedule.id", event.payload.id);
+			break;
+		case "schedule:duplicate_warning":
+			setIfPresent(attrs, "agent.schedule.callback", event.payload.callback);
 			break;
 		case "connect":
-			attrs["agent.connection.id"] = event.payload.connectionId;
+		case "disconnect":
+			setIfPresent(attrs, "agent.connection.id", event.payload.connectionId);
 			break;
 		case "mcp:client:preconnect":
-			attrs["agent.mcp.server_id"] = event.payload.serverId;
+			setIfPresent(attrs, "agent.mcp.server_id", event.payload.serverId);
 			break;
 		case "mcp:client:connect":
-			attrs["agent.mcp.url"] = event.payload.url;
-			attrs["agent.mcp.transport"] = event.payload.transport;
-			attrs["agent.mcp.state"] = event.payload.state;
-			if (event.payload.error) attrs["agent.mcp.error"] = event.payload.error;
+		case "mcp:client:close":
+			setIfPresent(attrs, "agent.mcp.url", event.payload.url);
+			setIfPresent(attrs, "agent.mcp.transport", event.payload.transport);
+			setIfPresent(attrs, "agent.mcp.state", event.payload.state);
 			break;
 		case "mcp:client:authorize":
-			attrs["agent.mcp.server_id"] = event.payload.serverId;
-			attrs["agent.mcp.auth_url"] = event.payload.authUrl;
-			if (event.payload.clientId) attrs["agent.mcp.client_id"] = event.payload.clientId;
+			setIfPresent(attrs, "agent.mcp.server_id", event.payload.serverId);
+			setIfPresent(attrs, "agent.mcp.auth_url", event.payload.authUrl);
+			setIfPresent(attrs, "agent.mcp.client_id", event.payload.clientId);
+			break;
+		case "mcp:client:discover":
+			setIfPresent(attrs, "agent.mcp.url", event.payload.url);
+			setIfPresent(attrs, "agent.mcp.state", event.payload.state);
+			setIfPresent(attrs, "agent.mcp.capability", event.payload.capability);
 			break;
 	}
-	for (const [key, value] of Object.entries(event.payload)) if (attrs[`agent.${key}`] === void 0 && (typeof value === "string" || typeof value === "number" || typeof value === "boolean")) attrs[`agent.payload.${key}`] = value;
+	for (const [key, value] of Object.entries(event.payload)) setIfPresent(attrs, `agent.payload.${key}`, value);
 	return attrs;
 }
-/**
-* Determine span kind based on event type
-*/
 function getSpanKind(event) {
-	switch (event.type) {
-		case "rpc": return SpanKind.SERVER;
-		case "connect": return SpanKind.SERVER;
-		case "mcp:client:connect":
-		case "mcp:client:preconnect":
-		case "mcp:client:authorize":
-		case "mcp:client:discover": return SpanKind.CLIENT;
+	switch (classifyEvent(event.type)) {
+		case "rpc":
+		case "lifecycle":
+		case "email": return SpanKind.SERVER;
+		case "mcp": return SpanKind.CLIENT;
+		case "schedule":
+		case "queue": return SpanKind.CONSUMER;
 		default: return SpanKind.INTERNAL;
 	}
 }
-/**
-* Check if an event type should be traced based on options
-*/
-function shouldTraceEvent(event, options) {
-	const opts = {
-		traceRpc: true,
-		traceSchedule: true,
-		traceMcp: true,
-		traceStateUpdates: false,
-		traceMessages: true,
-		traceLifecycle: true,
-		...options
-	};
-	switch (event.type) {
-		case "rpc": return opts.traceRpc ?? true;
-		case "schedule:create":
-		case "schedule:execute":
-		case "schedule:cancel": return opts.traceSchedule ?? true;
-		case "mcp:client:preconnect":
-		case "mcp:client:connect":
-		case "mcp:client:authorize":
-		case "mcp:client:discover": return opts.traceMcp ?? true;
-		case "state:update": return opts.traceStateUpdates ?? false;
-		case "message:request":
-		case "message:response":
-		case "message:clear": return opts.traceMessages ?? true;
-		case "connect":
-		case "destroy": return opts.traceLifecycle ?? true;
-		default: return true;
+function inferErrorMessage(event) {
+	const payload = event.payload;
+	const direct = payload.error;
+	if (typeof direct === "string" && direct.length > 0) return direct;
+	if (event.type === "workflow:rejected") {
+		const reason = payload.reason;
+		if (typeof reason === "string" && reason.length > 0) return reason;
+		return "workflow rejected";
 	}
+	if (event.type.endsWith(":failed") || event.type.endsWith(":error")) return event.type;
+}
+function isErrorEvent(event) {
+	if (event.type === "workflow:rejected") return true;
+	if (event.type.endsWith(":error") || event.type.endsWith(":failed")) return true;
+	if ("error" in event.payload) return typeof event.payload.error === "string";
+	return false;
+}
+function applyEventStatus(span, event) {
+	if (!isErrorEvent(event)) {
+		span.setStatus({ code: SpanStatusCode.OK });
+		return;
+	}
+	const message = inferErrorMessage(event);
+	span.setStatus({
+		code: SpanStatusCode.ERROR,
+		message
+	});
+	span.setAttribute("error", true);
+	if (message) span.setAttribute("exception.message", message);
 }
-/**
-* Export spans asynchronously
-*/
 async function exportSpans(traceId, ctx) {
 	const tracer = trace.getTracer("autotel-cloudflare/agents");
 	if (tracer instanceof WorkerTracer) try {
-		if (ctx && "scheduler" in ctx) {
-			const ctxWithScheduler = ctx;
-			if (ctxWithScheduler.scheduler) await ctxWithScheduler.scheduler.wait(1);
-		}
+		const scheduler = ctx && "scheduler" in ctx ? ctx.scheduler : void 0;
+		if (scheduler?.wait) await scheduler.wait(1);
 		await tracer.forceFlush(traceId);
 	} catch (error) {
 		console.error("[autotel-cloudflare/agents] Failed to export spans:", error);
 	}
-	if (ctx && "waitUntil" in ctx) {}
 }
 /**
 * OpenTelemetry-based Observability implementation
@@ -193,19 +257,11 @@ var OtelObservability = class {
 		this.config = initialiser({}, void 0);
 		this.options = config.agents ?? {};
 	}
-	/**
-	* Initialize the tracer provider (called lazily on first emit)
-	*/
 	initialize() {
 		if (this.initialized) return;
 		initProvider(this.config);
 		this.initialized = true;
 	}
-	/**
-	* Emit an observability event
-	*
-	* Converts the event to an OpenTelemetry span based on the event type.
-	*/
 	emit(event, ctx) {
 		this.initialize();
 		if (!shouldTraceEvent(event, this.options)) return;
@@ -213,63 +269,33 @@ var OtelObservability = class {
 		const spanName = this.options.spanNameFormatter ? this.options.spanNameFormatter(event) : getDefaultSpanName(event);
 		const defaultAttrs = getDefaultAttributes(event);
 		const customAttrs = this.options.attributeExtractor ? this.options.attributeExtractor(event) : {};
-		const attributes = {
-			...defaultAttrs,
-			...customAttrs
-		};
-		const kind = getSpanKind(event);
 		const span = tracer.startSpan(spanName, {
-			kind,
-			attributes,
+			kind: getSpanKind(event),
+			attributes: {
+				...defaultAttrs,
+				...customAttrs
+			},
 			startTime: event.timestamp
 		});
-		span.setStatus({ code: SpanStatusCode.OK });
+		if (event.type === "tool:approval") recordHumanApproval({
+			ctx: agentContextFromSpan(span),
+			toolCallId: event.payload.toolCallId,
+			approved: event.payload.approved,
+			required: true
+		});
+		applyEventStatus(span, event);
 		span.end(event.timestamp + 1);
-		activeSpans.set(event.id, span);
 		const traceId = span.spanContext().traceId;
-		if (ctx && "waitUntil" in ctx && typeof ctx.waitUntil === "function") ctx.waitUntil(exportSpans(traceId, ctx));
-		else exportSpans(traceId, ctx);
+		if (ctx && "waitUntil" in ctx && typeof ctx.waitUntil === "function") {
+			ctx.waitUntil(exportSpans(traceId, ctx));
+			return;
+		}
+		exportSpans(traceId, ctx);
 	}
 };
-/**
-* Create an OtelObservability instance
-*
-* @example
-* ```typescript
-* import { Agent } from 'agents'
-* import { createOtelObservability } from 'autotel-cloudflare/agents'
-*
-* class MyAgent extends Agent<Env> {
-*   observability = createOtelObservability({
-*     service: { name: 'my-agent' },
-*     exporter: { url: env.OTLP_ENDPOINT }
-*   })
-* }
-* ```
-*/
 function createOtelObservability(config) {
 	return new OtelObservability(config);
 }
-/**
-* Create an OtelObservability instance with environment-based config
-*
-* Use this when you need to access environment variables for configuration.
-*
-* @example
-* ```typescript
-* import { Agent } from 'agents'
-* import { createOtelObservabilityFromEnv } from 'autotel-cloudflare/agents'
-*
-* class MyAgent extends Agent<Env> {
-*   observability?: OtelObservability
-*
-*   constructor(state: DurableObjectState, env: Env) {
-*     super(state, env)
-*     this.observability = createOtelObservabilityFromEnv(env)
-*   }
-* }
-* ```
-*/
 function createOtelObservabilityFromEnv(env, options) {
 	const endpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT || void 0;
 	const serviceName = env.OTEL_SERVICE_NAME || "cloudflare-agent";
@@ -293,5 +319,68 @@ function createOtelObservabilityFromEnv(env, options) {
 }
 
 //#endregion
-export { OtelObservability, createOtelObservability, createOtelObservabilityFromEnv };
+//#region src/agents/observability.ts
+const listeners = {
+	state: /* @__PURE__ */ new Set(),
+	rpc: /* @__PURE__ */ new Set(),
+	message: /* @__PURE__ */ new Set(),
+	chat: /* @__PURE__ */ new Set(),
+	transcript: /* @__PURE__ */ new Set(),
+	fiber: /* @__PURE__ */ new Set(),
+	agentTool: /* @__PURE__ */ new Set(),
+	schedule: /* @__PURE__ */ new Set(),
+	lifecycle: /* @__PURE__ */ new Set(),
+	workflow: /* @__PURE__ */ new Set(),
+	mcp: /* @__PURE__ */ new Set(),
+	email: /* @__PURE__ */ new Set()
+};
+function createChannel(key, name) {
+	return {
+		name,
+		publish(event) {
+			for (const callback of listeners[key]) callback(event);
+		}
+	};
+}
+const channels = {
+	state: createChannel("state", "agents:state"),
+	rpc: createChannel("rpc", "agents:rpc"),
+	message: createChannel("message", "agents:message"),
+	chat: createChannel("chat", "agents:chat"),
+	transcript: createChannel("transcript", "agents:transcript"),
+	fiber: createChannel("fiber", "agents:fiber"),
+	agentTool: createChannel("agentTool", "agents:agent_tool"),
+	schedule: createChannel("schedule", "agents:schedule"),
+	lifecycle: createChannel("lifecycle", "agents:lifecycle"),
+	workflow: createChannel("workflow", "agents:workflow"),
+	mcp: createChannel("mcp", "agents:mcp"),
+	email: createChannel("email", "agents:email")
+};
+function getChannel(type) {
+	if (type.startsWith("mcp:")) return channels.mcp;
+	if (type.startsWith("workflow:")) return channels.workflow;
+	if (type.startsWith("fiber:")) return channels.fiber;
+	if (type.startsWith("transcript:") || type.startsWith("chat:transcript:")) return channels.transcript;
+	if (type.startsWith("chat:")) return channels.chat;
+	if (type.startsWith("agent_tool:")) return channels.agentTool;
+	if (type.startsWith("schedule:") || type.startsWith("queue:")) return channels.schedule;
+	if (type.startsWith("message:") || type.startsWith("tool:") || type.startsWith("submission:")) return channels.message;
+	if (type === "rpc" || type.startsWith("rpc:")) return channels.rpc;
+	if (type.startsWith("state:")) return channels.state;
+	if (type.startsWith("email:")) return channels.email;
+	return channels.lifecycle;
+}
+const genericObservability = { emit(event) {
+	getChannel(event.type).publish(event);
+} };
+function subscribe(channelKey, callback) {
+	const bucket = listeners[channelKey];
+	bucket.add(callback);
+	return () => {
+		bucket.delete(callback);
+	};
+}
+
+//#endregion
+export { OtelObservability, channels, createOtelObservability, createOtelObservabilityFromEnv, genericObservability, subscribe };
 //# sourceMappingURL=agents.js.map