@runtypelabs/cloudflare-agents 0.1.1

package/dist/index.cjs

@@ -0,0 +1,344 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_identity = require("./chunk-DBVUQIKL.cjs");
+//#region src/content.ts
+const MAX_CONTENT_BYTES = 32768;
+function diagnose$1(policy, code) {
+	try {
+		policy.onDiagnostic?.(code);
+	} catch {
+		return;
+	}
+}
+function isEnabled(policy, kind) {
+	if (kind === "instructions") return policy.instructions ?? policy.messages ?? false;
+	if (kind === "error") return policy.errors ?? false;
+	return policy[kind] ?? false;
+}
+/** Applies privacy policy before a content value can enter telemetry storage. */
+function captureContent(policy, kind, value) {
+	if (!isEnabled(policy, kind) || value === void 0) return void 0;
+	const limit = policy.maxBytes ?? MAX_CONTENT_BYTES;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_CONTENT_BYTES) {
+		diagnose$1(policy, "content_invalid");
+		return;
+	}
+	let detached;
+	try {
+		detached = JSON.parse(JSON.stringify(value));
+	} catch {
+		diagnose$1(policy, "content_invalid");
+		return;
+	}
+	let redacted;
+	try {
+		redacted = policy.redact ? policy.redact(kind, detached) : detached;
+	} catch {
+		diagnose$1(policy, "content_redaction_failed");
+		return;
+	}
+	if (redacted === void 0) return void 0;
+	try {
+		const serialized = JSON.stringify(redacted);
+		if (serialized === void 0) {
+			diagnose$1(policy, "content_invalid");
+			return;
+		}
+		if (new TextEncoder().encode(serialized).byteLength > limit) {
+			diagnose$1(policy, "content_too_large");
+			return;
+		}
+		return JSON.parse(serialized);
+	} catch {
+		diagnose$1(policy, "content_invalid");
+		return;
+	}
+}
+//#endregion
+//#region src/observer.ts
+/** Adds bounded observation callbacks without reading or replacing the response stream. */
+async function observeStreamTextOptions(options, observation) {
+	const destination = observation.observer;
+	let deliveryFailed = false;
+	observation = {
+		...observation,
+		turn: { ...observation.turn },
+		observer: {
+			onDiagnostic: destination.onDiagnostic,
+			async emit(event) {
+				const terminal = event.kind === "finished" || event.kind === "aborted" || event.kind === "errored";
+				const outgoing = deliveryFailed && terminal ? {
+					kind: "incomplete",
+					turn: event.turn,
+					reason: "observation_delivery_failed"
+				} : event;
+				try {
+					await destination.emit(outgoing);
+				} catch (error) {
+					deliveryFailed = true;
+					throw error;
+				}
+			}
+		}
+	};
+	await emit(observation.observer, {
+		kind: "accepted",
+		turn: observation.turn
+	});
+	if (observation.turn.continuation) await emit(observation.observer, {
+		kind: "unsupported",
+		turn: observation.turn,
+		reason: "continuation"
+	});
+	const pendingToolCalls = /* @__PURE__ */ new Set();
+	const completedServerToolCalls = /* @__PURE__ */ new Set();
+	let lastToolError;
+	return {
+		...options,
+		experimental_onStart: options.experimental_onStart,
+		experimental_onStepStart: wrap(options.experimental_onStepStart, async (event) => {
+			await emitModelInput(observation, event, event.stepNumber);
+		}),
+		experimental_onToolCallStart: wrap(options.experimental_onToolCallStart, async (event) => {
+			await emit(observation.observer, {
+				kind: "tool_started",
+				turn: observation.turn,
+				stepNumber: event.stepNumber,
+				...model(event.model) ? { model: model(event.model) } : {},
+				toolCall: toolCall(observation, event.toolCall)
+			});
+		}),
+		experimental_onToolCallFinish: wrap(options.experimental_onToolCallFinish, async (event) => {
+			const id = toolCallId(event.toolCall);
+			if (id) completedServerToolCalls.add(id);
+			const output = event.success ? captureContent(observation.content, "tools", event.output) : void 0;
+			const error = event.success ? void 0 : captureError(observation.content, event.error);
+			if (!event.success) lastToolError = error;
+			const outcome = event.success ? output === void 0 ? {} : { output } : error === void 0 ? {} : { error };
+			await emit(observation.observer, {
+				kind: "tool_finished",
+				turn: observation.turn,
+				stepNumber: event.stepNumber,
+				...model(event.model) ? { model: model(event.model) } : {},
+				toolCall: toolCall(observation, event.toolCall),
+				durationMs: boundedDuration(event.durationMs),
+				success: event.success,
+				...outcome
+			});
+		}),
+		onStepFinish: wrap(options.onStepFinish, async (event) => {
+			updatePendingToolCalls(pendingToolCalls, event);
+			for (const id of completedServerToolCalls) pendingToolCalls.delete(id);
+			await emit(observation.observer, modelStep(observation, event));
+		}),
+		onFinish: wrap(options.onFinish, async (event) => {
+			if (observation.turn.continuation) return;
+			for (const id of completedServerToolCalls) pendingToolCalls.delete(id);
+			const terminalToolError = event.finishReason === "tool-calls" && event.content.some((part) => part.type === "tool-error");
+			if (event.finishReason === "error" || terminalToolError) {
+				await emit(observation.observer, {
+					kind: "errored",
+					turn: observation.turn,
+					...lastToolError === void 0 ? {} : { error: lastToolError }
+				});
+				return;
+			}
+			if (pendingToolCalls.size > 0) {
+				await emit(observation.observer, {
+					kind: "unsupported",
+					turn: observation.turn,
+					reason: "unresolved_tool_calls"
+				});
+				return;
+			}
+			await emit(observation.observer, {
+				kind: "finished",
+				turn: observation.turn
+			});
+		}),
+		onAbort: wrap(options.onAbort, async () => {
+			await emit(observation.observer, {
+				kind: "aborted",
+				turn: observation.turn
+			});
+		}),
+		onError: wrap(options.onError, async (event) => {
+			const error = captureError(observation.content, event.error);
+			await emit(observation.observer, {
+				kind: "errored",
+				turn: observation.turn,
+				...error === void 0 ? {} : { error }
+			});
+		})
+	};
+}
+function wrap(existing, observe) {
+	return async (event) => {
+		await existing?.(event);
+		try {
+			await observe(event);
+		} catch {
+			return;
+		}
+	};
+}
+async function emit(observer, event) {
+	try {
+		await observer.emit(event);
+	} catch {
+		diagnose(observer, "observer_emit_failed");
+	}
+}
+function diagnose(observer, code) {
+	try {
+		observer.onDiagnostic?.(code);
+	} catch {
+		return;
+	}
+}
+function emitModelInput(observation, event, stepNumber) {
+	const system = captureContent(observation.content, "instructions", event.system);
+	const messages = captureMessages(observation.content, event.messages);
+	return emit(observation.observer, {
+		kind: "model_input",
+		turn: observation.turn,
+		stepNumber,
+		model: model(event.model) ?? {
+			provider: "",
+			modelId: ""
+		},
+		...system === void 0 ? {} : { system },
+		...messages === void 0 ? {} : { messages }
+	});
+}
+function modelStep(observation, event) {
+	const output = captureContent(observation.content, "messages", event.text);
+	const toolCalls = toolsEnabled(observation.content) ? captureContent(observation.content, "tools", event.toolCalls) : void 0;
+	const toolResults = toolsEnabled(observation.content) ? captureContent(observation.content, "tools", event.toolResults) : void 0;
+	const finishReason = boundedString(event.finishReason);
+	return {
+		kind: "model_step",
+		turn: observation.turn,
+		stepNumber: event.stepNumber,
+		model: model(event.model) ?? {
+			provider: "",
+			modelId: ""
+		},
+		...output === void 0 ? {} : { output },
+		...toolCalls === void 0 ? {} : { toolCalls },
+		...toolResults === void 0 ? {} : { toolResults },
+		...finishReason === void 0 ? {} : { finishReason },
+		usage: usage(event.usage)
+	};
+}
+function updatePendingToolCalls(pendingToolCalls, event) {
+	for (const call of event.toolCalls) {
+		const id = toolCallId(call);
+		if (id) pendingToolCalls.add(id);
+	}
+	for (const result of event.toolResults) {
+		const id = toolCallId(result);
+		if (id) pendingToolCalls.delete(id);
+	}
+}
+function toolCallId(value) {
+	if (!value || typeof value !== "object") return void 0;
+	return boundedString(value.toolCallId);
+}
+function captureMessages(policy, messages) {
+	if (!Array.isArray(messages)) return captureContent(policy, "messages", messages);
+	const captured = messages.flatMap((message) => {
+		const value = captureMessage(policy, message);
+		return value === void 0 ? [] : [value];
+	});
+	return captured.length === 0 ? void 0 : captured;
+}
+function captureMessage(policy, message) {
+	const kind = messageKind(message);
+	if (kind !== "messages") return captureContent(policy, kind, message);
+	if (!message || typeof message !== "object") return captureContent(policy, "messages", message);
+	const content = message.content;
+	if (!Array.isArray(content)) return captureContent(policy, "messages", message);
+	const capturedContent = content.flatMap((part) => {
+		const value = captureContent(policy, partKind(part), part);
+		return value === void 0 ? [] : [value];
+	});
+	if (capturedContent.length === 0) return void 0;
+	return captureContent(policy, "messages", {
+		...message,
+		content: capturedContent
+	});
+}
+function messageKind(message) {
+	if (!message || typeof message !== "object") return "messages";
+	const role = message.role;
+	if (role === "system" || role === "developer") return "instructions";
+	return role === "tool" ? "tools" : "messages";
+}
+function partKind(part) {
+	if (!part || typeof part !== "object") return "messages";
+	const type = part.type;
+	return typeof type === "string" && type.startsWith("tool-") ? "tools" : "messages";
+}
+function toolsEnabled(policy) {
+	return policy.tools === true;
+}
+function toolCall(observation, value) {
+	if (!value || typeof value !== "object") {
+		diagnose(observation.observer, "invalid_sdk_event");
+		return {};
+	}
+	const call = value;
+	const toolCallId = boundedString(call.toolCallId);
+	const toolName = boundedString(call.toolName);
+	const input = captureContent(observation.content, "tools", call.input);
+	return {
+		...toolCallId === void 0 ? {} : { toolCallId },
+		...toolName === void 0 ? {} : { toolName },
+		...input === void 0 ? {} : { input }
+	};
+}
+function model(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const candidate = value;
+	const provider = boundedString(candidate.provider);
+	const modelId = boundedString(candidate.modelId);
+	return provider && modelId ? {
+		provider,
+		modelId
+	} : void 0;
+}
+function captureError(policy, error) {
+	if (error instanceof Error) return captureContent(policy, "error", {
+		name: error.name,
+		message: error.message
+	});
+	return captureContent(policy, "error", error);
+}
+function boundedString(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= 512 ? value : void 0;
+}
+function boundedDuration(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+function usage(value) {
+	if (!value || typeof value !== "object") return {};
+	return Object.fromEntries(Object.entries(value).filter(([, amount]) => typeof amount === "number" && Number.isFinite(amount) && amount >= 0));
+}
+//#endregion
+//#region src/durable-observer.ts
+/** Bridges a companion Durable Object receipt to the observer's delivery diagnostic. */
+function createDurableObserver(sink, onDiagnostic) {
+	return {
+		onDiagnostic,
+		async emit(observation) {
+			if (!(await sink.observe(observation)).accepted) throw new Error("Durable adapter observation was not accepted");
+		}
+	};
+}
+//#endregion
+exports.captureContent = captureContent;
+exports.createDurableObserver = createDurableObserver;
+exports.createRunIdentity = require_identity.createRunIdentity;
+exports.observeStreamTextOptions = observeStreamTextOptions;
+exports.operationSpanId = require_identity.operationSpanId;
+

package/dist/index.d.cts

@@ -0,0 +1,13 @@
+import { _ as operationSpanId, c as observeStreamTextOptions, d as ContentKind, f as ContentPolicy, g as createRunIdentity, h as SubmissionIdentity, i as AdapterObserver, l as CapturedJson, m as RunIdentity, o as AdapterTurn, p as captureContent, r as AdapterObservation, s as ObserveStreamTextOptions, u as ContentDiagnostic } from "./observer-DnEMHl8z.cjs";
+//#region src/durable-observer.d.ts
+interface DurableObservationSink {
+  observe(observation: AdapterObservation): Promise<{
+    accepted: boolean;
+    diagnostic?: string;
+  }>;
+}
+/** Bridges a companion Durable Object receipt to the observer's delivery diagnostic. */
+export declare function createDurableObserver(sink: DurableObservationSink, onDiagnostic?: AdapterObserver['onDiagnostic']): AdapterObserver;
+//#endregion
+export { type AdapterObservation, type AdapterObserver, type AdapterTurn, type CapturedJson, type ContentDiagnostic, type ContentKind, type ContentPolicy, type DurableObservationSink, type ObserveStreamTextOptions, type RunIdentity, type SubmissionIdentity, captureContent, createRunIdentity, observeStreamTextOptions, operationSpanId };
+export {}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import { _ as operationSpanId, c as observeStreamTextOptions, d as ContentKind, f as ContentPolicy, g as createRunIdentity, h as SubmissionIdentity, i as AdapterObserver, l as CapturedJson, m as RunIdentity, o as AdapterTurn, p as captureContent, r as AdapterObservation, s as ObserveStreamTextOptions, u as ContentDiagnostic } from "./observer-DnEMHl8z.js";
+//#region src/durable-observer.d.ts
+interface DurableObservationSink {
+  observe(observation: AdapterObservation): Promise<{
+    accepted: boolean;
+    diagnostic?: string;
+  }>;
+}
+/** Bridges a companion Durable Object receipt to the observer's delivery diagnostic. */
+export declare function createDurableObserver(sink: DurableObservationSink, onDiagnostic?: AdapterObserver['onDiagnostic']): AdapterObserver;
+//#endregion
+export { type AdapterObservation, type AdapterObserver, type AdapterTurn, type CapturedJson, type ContentDiagnostic, type ContentKind, type ContentPolicy, type DurableObservationSink, type ObserveStreamTextOptions, type RunIdentity, type SubmissionIdentity, captureContent, createRunIdentity, observeStreamTextOptions, operationSpanId };
+export {}