@llmops/sdk 0.5.2-beta.1 → 0.5.3-beta.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { t as createLLMOpsMiddleware } from "./express-Dz3xwxkh.mjs";
-import "@llmops/core";
+import { LLMOPS_SPAN_NAME_HEADER, LLMOPS_TRACE_ID_HEADER, LLMOPS_TRACE_NAME_HEADER } from "@llmops/core";
 import { createApp } from "@llmops/app";
 
 //#region src/lib/auth/client.ts
@@ -19,22 +19,362 @@ const createLLMOps = (config) => {
 	const { app, config: validatedConfig } = createApp(config);
 	const handler = async (req) => app.fetch(req, void 0, void 0);
 	const basePath = validatedConfig.basePath;
-	const internalFetch = (input, init) => {
-		const request = new Request(input, init);
-		const url = new URL(request.url);
-		if (basePath && basePath !== "/" && url.pathname.startsWith(basePath)) url.pathname = url.pathname.slice(basePath.length) || "/";
-		return handler(new Request(url.toString(), request));
+	const createInternalFetch = (getTraceContext) => {
+		return (input, init) => {
+			const request = new Request(input, init);
+			const url = new URL(request.url);
+			if (basePath && basePath !== "/" && url.pathname.startsWith(basePath)) url.pathname = url.pathname.slice(basePath.length) || "/";
+			if (getTraceContext) {
+				const ctx = getTraceContext();
+				if (ctx) {
+					const headers = new Headers(request.headers);
+					if (ctx.traceId) headers.set(LLMOPS_TRACE_ID_HEADER, ctx.traceId);
+					if (ctx.traceName) headers.set(LLMOPS_TRACE_NAME_HEADER, ctx.traceName);
+					if (ctx.spanName) headers.set(LLMOPS_SPAN_NAME_HEADER, ctx.spanName);
+					return handler(new Request(url.toString(), {
+						method: request.method,
+						headers,
+						body: request.body,
+						duplex: "half"
+					}));
+				}
+			}
+			return handler(new Request(url.toString(), request));
+		};
 	};
 	return {
 		handler,
 		config: Object.freeze(validatedConfig),
-		provider: () => ({
+		provider: (options) => ({
 			baseURL: `http://localhost${basePath}/api/genai/v1`,
 			apiKey: "llmops",
-			fetch: internalFetch
+			fetch: createInternalFetch(options?.traceContext)
 		})
 	};
 };
 
 //#endregion
-export { AuthFeatureNotAvailableError, createLLMOpsMiddleware, createLLMOps as llmops };
+//#region src/telemetry/exporter.ts
+let ExportResultCode = /* @__PURE__ */ function(ExportResultCode$1) {
+	ExportResultCode$1[ExportResultCode$1["SUCCESS"] = 0] = "SUCCESS";
+	ExportResultCode$1[ExportResultCode$1["FAILED"] = 1] = "FAILED";
+	return ExportResultCode$1;
+}({});
+/**
+* Convert a value to OTLP attribute value format
+*/
+function toOtlpValue$1(value) {
+	if (typeof value === "string") return { stringValue: value };
+	if (typeof value === "number") return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+	if (typeof value === "boolean") return { boolValue: value };
+	if (Array.isArray(value)) return { arrayValue: { values: value.map((v) => toOtlpValue$1(v)) } };
+	if (typeof value === "object" && value !== null) try {
+		return { stringValue: JSON.stringify(value) };
+	} catch {
+		return { stringValue: String(value) };
+	}
+	return { stringValue: String(value) };
+}
+/**
+* Convert HrTime [seconds, nanoseconds] to nanosecond string
+*/
+function hrTimeToNano(hrTime) {
+	return (BigInt(hrTime[0]) * BigInt(1e9) + BigInt(hrTime[1])).toString();
+}
+/**
+* Create an OTel SpanExporter that sends spans to an LLMOps server.
+*/
+function createLLMOpsSpanExporter(config) {
+	const url = `${config.baseURL.replace(/\/$/, "")}/api/otlp/v1/traces`;
+	return {
+		export(spans, resultCallback) {
+			const resourceMap = /* @__PURE__ */ new Map();
+			for (const span of spans) {
+				const resourceKey = JSON.stringify(span.resource.attributes);
+				const group = resourceMap.get(resourceKey) ?? [];
+				group.push(span);
+				resourceMap.set(resourceKey, group);
+			}
+			const body = { resourceSpans: Array.from(resourceMap.entries()).map(([resourceKey, group]) => {
+				const resourceAttrs = JSON.parse(resourceKey);
+				const scopeMap = /* @__PURE__ */ new Map();
+				for (const span of group) {
+					const scopeKey = `${span.instrumentationLibrary.name}:${span.instrumentationLibrary.version ?? ""}`;
+					const scopeGroup = scopeMap.get(scopeKey) ?? [];
+					scopeGroup.push(span);
+					scopeMap.set(scopeKey, scopeGroup);
+				}
+				return {
+					resource: { attributes: Object.entries(resourceAttrs).filter(([, v]) => v !== void 0 && v !== null).map(([key, value]) => ({
+						key,
+						value: toOtlpValue$1(value)
+					})) },
+					scopeSpans: Array.from(scopeMap.entries()).map(([, scopeGroup]) => ({
+						scope: {
+							name: scopeGroup[0].instrumentationLibrary.name,
+							version: scopeGroup[0].instrumentationLibrary.version ?? void 0
+						},
+						spans: scopeGroup.map((span) => {
+							const ctx = span.spanContext();
+							return {
+								traceId: ctx.traceId,
+								spanId: ctx.spanId,
+								parentSpanId: span.parentSpanId || void 0,
+								name: span.name,
+								kind: span.kind,
+								startTimeUnixNano: hrTimeToNano(span.startTime),
+								endTimeUnixNano: hrTimeToNano(span.endTime),
+								attributes: Object.entries(span.attributes).filter(([, v]) => v !== void 0 && v !== null).map(([key, value]) => ({
+									key,
+									value: toOtlpValue$1(value)
+								})),
+								events: span.events.map((event) => ({
+									name: event.name,
+									timeUnixNano: hrTimeToNano(event.time),
+									attributes: event.attributes ? Object.entries(event.attributes).filter(([, v]) => v !== void 0 && v !== null).map(([key, value]) => ({
+										key,
+										value: toOtlpValue$1(value)
+									})) : []
+								})),
+								status: {
+									code: span.status.code,
+									message: span.status.message ?? void 0
+								}
+							};
+						})
+					}))
+				};
+			}) };
+			fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					Authorization: `Bearer ${config.apiKey}`,
+					...config.headers ?? {}
+				},
+				body: JSON.stringify(body)
+			}).then((res) => {
+				if (res.ok) resultCallback({ code: ExportResultCode.SUCCESS });
+				else resultCallback({
+					code: ExportResultCode.FAILED,
+					error: /* @__PURE__ */ new Error(`OTLP export failed: ${res.status}`)
+				});
+			}).catch((error) => {
+				resultCallback({
+					code: ExportResultCode.FAILED,
+					error: error instanceof Error ? error : new Error(String(error))
+				});
+			});
+		},
+		async shutdown() {},
+		async forceFlush() {}
+	};
+}
+
+//#endregion
+//#region src/telemetry/agents-exporter.ts
+function normalizeTraceId(id) {
+	return id.startsWith("trace_") ? id.slice(6) : id;
+}
+function normalizeSpanId(id) {
+	return id.startsWith("span_") ? id.slice(5) : id;
+}
+function isoToNano(iso) {
+	if (!iso) return "0";
+	const ms = new Date(iso).getTime();
+	if (isNaN(ms)) return "0";
+	return (BigInt(ms) * BigInt(1e6)).toString();
+}
+function toOtlpValue(value) {
+	if (typeof value === "string") return { stringValue: value };
+	if (typeof value === "number") return Number.isInteger(value) ? { intValue: String(value) } : { doubleValue: value };
+	if (typeof value === "boolean") return { boolValue: value };
+	if (Array.isArray(value)) return { arrayValue: { values: value.map((v) => toOtlpValue(v)) } };
+	if (typeof value === "object" && value !== null) try {
+		return { stringValue: JSON.stringify(value) };
+	} catch {
+		return { stringValue: String(value) };
+	}
+	return { stringValue: String(value) };
+}
+function kv(key, value) {
+	return {
+		key,
+		value: toOtlpValue(value)
+	};
+}
+/**
+* Derive a human-readable span name from the span data type.
+*/
+function deriveSpanName(data) {
+	switch (data.type) {
+		case "agent": return `Agent: ${data.name}`;
+		case "function": return `Tool: ${data.name}`;
+		case "generation": return data.model ? `Generation: ${data.model}` : "Generation";
+		case "response": return "Response";
+		case "handoff": return `Handoff: ${data.from_agent ?? "?"} → ${data.to_agent ?? "?"}`;
+		case "guardrail": return `Guardrail: ${data.name}`;
+		case "custom": return `Custom: ${data.name}`;
+		case "transcription": return data.model ? `Transcription: ${data.model}` : "Transcription";
+		case "speech": return data.model ? `Speech: ${data.model}` : "Speech";
+		case "speech_group": return "Speech Group";
+		case "mcp_tools": return `MCP Tools: ${data.server ?? "unknown"}`;
+		default: return "Unknown Span";
+	}
+}
+/**
+* Convert span data fields to OTLP attributes that our UI's getSpanType() recognizes.
+*/
+function convertSpanDataToAttributes(data, error) {
+	const attrs = [kv("openai.agents.span_type", data.type)];
+	switch (data.type) {
+		case "generation":
+			attrs.push(kv("gen_ai.operation.name", "chat"));
+			if (data.model) {
+				attrs.push(kv("gen_ai.request.model", data.model));
+				attrs.push(kv("gen_ai.system", "openai"));
+			}
+			if (data.usage?.input_tokens != null) attrs.push(kv("gen_ai.usage.input_tokens", data.usage.input_tokens));
+			if (data.usage?.output_tokens != null) attrs.push(kv("gen_ai.usage.output_tokens", data.usage.output_tokens));
+			if (data.input) attrs.push(kv("ai.prompt.messages", JSON.stringify(data.input)));
+			if (data.output) attrs.push(kv("gen_ai.completion", JSON.stringify(data.output)));
+			if (data.model_config) attrs.push(kv("gen_ai.request.model_config", JSON.stringify(data.model_config)));
+			break;
+		case "agent":
+			attrs.push(kv("openai.agents.agent.name", data.name));
+			if (data.tools?.length) attrs.push(kv("openai.agents.agent.tools", JSON.stringify(data.tools)));
+			if (data.handoffs?.length) attrs.push(kv("openai.agents.agent.handoffs", JSON.stringify(data.handoffs)));
+			if (data.output_type) attrs.push(kv("openai.agents.agent.output_type", data.output_type));
+			break;
+		case "function":
+			attrs.push(kv("gen_ai.tool.name", data.name));
+			if (data.input) attrs.push(kv("ai.prompt.messages", data.input));
+			if (data.output) attrs.push(kv("ai.response.text", data.output));
+			if (data.mcp_data) attrs.push(kv("openai.agents.function.mcp_data", data.mcp_data));
+			break;
+		case "handoff":
+			if (data.from_agent) attrs.push(kv("openai.agents.handoff.from_agent", data.from_agent));
+			if (data.to_agent) attrs.push(kv("openai.agents.handoff.to_agent", data.to_agent));
+			break;
+		case "guardrail":
+			attrs.push(kv("llmops.guardrail.action", data.triggered ? "triggered" : "passed"));
+			attrs.push(kv("openai.agents.guardrail.name", data.name));
+			break;
+		case "response":
+			attrs.push(kv("gen_ai.operation.name", "chat"));
+			if (data.response_id) attrs.push(kv("openai.agents.response.id", data.response_id));
+			break;
+		case "custom":
+			attrs.push(kv("openai.agents.custom.name", data.name));
+			attrs.push(kv("openai.agents.custom.data", JSON.stringify(data.data)));
+			break;
+		case "transcription":
+			attrs.push(kv("gen_ai.operation.name", "transcription"));
+			if (data.model) attrs.push(kv("gen_ai.request.model", data.model));
+			if (data.output) attrs.push(kv("ai.response.text", data.output));
+			break;
+		case "speech":
+			attrs.push(kv("gen_ai.operation.name", "speech"));
+			if (data.model) attrs.push(kv("gen_ai.request.model", data.model));
+			if (data.input) attrs.push(kv("ai.prompt.messages", data.input));
+			break;
+		case "speech_group":
+			if (data.input) attrs.push(kv("openai.agents.speech_group.input", data.input));
+			break;
+		case "mcp_tools":
+			attrs.push(kv("gen_ai.tool.name", `mcp:${data.server ?? "unknown"}`));
+			if (data.result) attrs.push(kv("openai.agents.mcp.tools", JSON.stringify(data.result)));
+			break;
+	}
+	if (error) {
+		attrs.push(kv("error.message", error.message));
+		if (error.data) attrs.push(kv("error.data", JSON.stringify(error.data)));
+	}
+	return attrs;
+}
+function buildResourceSpans(traceId, trace, spans) {
+	const resourceAttrs = [kv("service.name", "@openai/agents")];
+	if (trace) {
+		resourceAttrs.push(kv("openai.agents.trace.name", trace.name));
+		if (trace.groupId) resourceAttrs.push(kv("openai.agents.trace.group_id", trace.groupId));
+		if (trace.metadata && Object.keys(trace.metadata).length > 0) resourceAttrs.push(kv("openai.agents.trace.metadata", JSON.stringify(trace.metadata)));
+	}
+	const normalizedTraceId = normalizeTraceId(traceId);
+	return {
+		resource: { attributes: resourceAttrs },
+		scopeSpans: [{
+			scope: { name: "@llmops/agents-exporter" },
+			spans: spans.map((span) => {
+				const isError = !!span.error;
+				return {
+					traceId: normalizedTraceId,
+					spanId: normalizeSpanId(span.spanId),
+					parentSpanId: span.parentId ? normalizeSpanId(span.parentId) : void 0,
+					name: deriveSpanName(span.spanData),
+					kind: 1,
+					startTimeUnixNano: isoToNano(span.startedAt),
+					endTimeUnixNano: isoToNano(span.endedAt),
+					attributes: convertSpanDataToAttributes(span.spanData, span.error),
+					events: [],
+					status: isError ? {
+						code: 2,
+						message: span.error.message
+					} : { code: 1 }
+				};
+			})
+		}]
+	};
+}
+/**
+* Create a TracingExporter for @openai/agents that sends traces to LLMOps.
+*
+* Usage:
+* ```typescript
+* import { createLLMOpsAgentsExporter } from '@llmops/sdk';
+* import { setTraceProcessors, BatchTraceProcessor } from '@openai/agents';
+*
+* setTraceProcessors([
+*   new BatchTraceProcessor(createLLMOpsAgentsExporter({
+*     baseURL: 'http://localhost:5177',
+*     apiKey: process.env.LLMOPS_API_KEY!,
+*   }))
+* ]);
+* ```
+*/
+function createLLMOpsAgentsExporter(config) {
+	const url = `${config.baseURL.replace(/\/$/, "")}/api/otlp/v1/traces`;
+	return { async export(items, signal) {
+		const traces = [];
+		const spans = [];
+		for (const item of items) if (item.type === "trace") traces.push(item);
+		else spans.push(item);
+		if (spans.length === 0) return;
+		const traceMap = /* @__PURE__ */ new Map();
+		for (const t of traces) traceMap.set(t.traceId, t);
+		const spansByTrace = /* @__PURE__ */ new Map();
+		for (const s of spans) {
+			const group = spansByTrace.get(s.traceId) ?? [];
+			group.push(s);
+			spansByTrace.set(s.traceId, group);
+		}
+		const resourceSpans = [];
+		for (const [traceId, traceSpans] of spansByTrace) {
+			const trace = traceMap.get(traceId);
+			resourceSpans.push(buildResourceSpans(traceId, trace, traceSpans));
+		}
+		if (resourceSpans.length === 0) return;
+		await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${config.apiKey}`,
+				...config.headers ?? {}
+			},
+			body: JSON.stringify({ resourceSpans }),
+			signal
+		});
+	} };
+}
+
+//#endregion
+export { AuthFeatureNotAvailableError, createLLMOpsAgentsExporter, createLLMOpsMiddleware, createLLMOpsSpanExporter, createLLMOps as llmops };

package/dist/nextjs.d.cts

@@ -1,4 +1,4 @@
-import { t as LLMOpsClient } from "./index-De3QdpKX.cjs";
+import { t as LLMOpsClient } from "./index-DdwqBi1V.cjs";
 
 //#region src/lib/nextjs/index.d.ts
 declare function toNextJsHandler(client: LLMOpsClient): {

package/dist/nextjs.d.mts

@@ -1,4 +1,4 @@
-import { t as LLMOpsClient } from "./index-BkLZoEW_.mjs";
+import { t as LLMOpsClient } from "./index-BvYAMh37.mjs";
 
 //#region src/lib/nextjs/index.d.ts
 declare function toNextJsHandler(client: LLMOpsClient): {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llmops/sdk",
-  "version": "0.5.2-beta.1",
+  "version": "0.5.3-beta.1",
   "description": "An LLMOps toolkit for TypeScript applications",
   "type": "module",
   "license": "Apache-2.0",
@@ -74,8 +74,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@llmops/app": "^0.5.2-beta.1",
-    "@llmops/core": "^0.5.2-beta.1"
+    "@llmops/core": "^0.5.3-beta.1",
+    "@llmops/app": "^0.5.3-beta.1"
   },
   "devDependencies": {
     "@types/express": "^5.0.6",