@llmops/sdk 0.5.4 → 0.6.0

package/dist/agents-exporter-DvECkYQd.d.cts

@@ -0,0 +1,155 @@
+//#region src/telemetry/agents-exporter.d.ts
+/**
+ * LLMOps Tracing Exporter for @openai/agents
+ *
+ * Implements the TracingExporter interface from @openai/agents-core, converting
+ * the agents framework's Trace/Span format to OTLP JSON and sending it to
+ * the LLMOps OTLP ingestion endpoint.
+ *
+ * No dependency on @openai/agents — types are defined inline using structural
+ * compatibility (same pattern as the OTel exporter).
+ *
+ * @example
+ * ```typescript
+ * import { createLLMOpsAgentsExporter } from '@llmops/sdk';
+ * import { setTraceProcessors, BatchTraceProcessor } from '@openai/agents';
+ *
+ * const exporter = createLLMOpsAgentsExporter({
+ *   baseURL: 'http://localhost:5177',
+ *   apiKey: process.env.LLMOPS_API_KEY!,
+ * });
+ *
+ * setTraceProcessors([new BatchTraceProcessor(exporter)]);
+ *
+ * // All @openai/agents traces now flow to LLMOps automatically
+ * ```
+ */
+/** Matches TracingExporter from @openai/agents-core */
+interface AgentsTracingExporter {
+  export(items: (AgentsTrace | AgentsSpan)[], signal?: AbortSignal): Promise<void>;
+}
+/** Matches Trace from @openai/agents-core */
+interface AgentsTrace {
+  type: 'trace';
+  traceId: string;
+  name: string;
+  groupId?: string | null;
+  metadata?: Record<string, unknown>;
+}
+/** Matches SpanError from @openai/agents-core */
+interface AgentsSpanError {
+  message: string;
+  data?: Record<string, unknown>;
+}
+/** Matches Span from @openai/agents-core */
+interface AgentsSpan {
+  type: 'trace.span';
+  spanId: string;
+  traceId: string;
+  parentId?: string | null;
+  startedAt?: string | null;
+  endedAt?: string | null;
+  error?: AgentsSpanError | null;
+  spanData: AgentsSpanData;
+}
+type AgentSpanData = {
+  type: 'agent';
+  name: string;
+  handoffs?: string[];
+  tools?: string[];
+  output_type?: string;
+};
+type FunctionSpanData = {
+  type: 'function';
+  name: string;
+  input: string;
+  output: string;
+  mcp_data?: string;
+};
+type GenerationUsageData = {
+  input_tokens?: number;
+  output_tokens?: number;
+  details?: Record<string, unknown> | null;
+  [key: string]: unknown;
+};
+type GenerationSpanData = {
+  type: 'generation';
+  input?: Record<string, unknown>[];
+  output?: Record<string, unknown>[];
+  model?: string;
+  model_config?: Record<string, unknown>;
+  usage?: GenerationUsageData;
+};
+type ResponseSpanData = {
+  type: 'response';
+  response_id?: string;
+  [key: string]: unknown;
+};
+type HandoffSpanData = {
+  type: 'handoff';
+  from_agent?: string;
+  to_agent?: string;
+};
+type CustomSpanData = {
+  type: 'custom';
+  name: string;
+  data: Record<string, unknown>;
+};
+type GuardrailSpanData = {
+  type: 'guardrail';
+  name: string;
+  triggered: boolean;
+};
+type TranscriptionSpanData = {
+  type: 'transcription';
+  input: unknown;
+  output?: string;
+  model?: string;
+  model_config?: Record<string, unknown>;
+};
+type SpeechSpanData = {
+  type: 'speech';
+  input?: string;
+  output: unknown;
+  model?: string;
+  model_config?: Record<string, unknown>;
+};
+type SpeechGroupSpanData = {
+  type: 'speech_group';
+  input?: string;
+};
+type MCPListToolsSpanData = {
+  type: 'mcp_tools';
+  server?: string;
+  result?: string[];
+};
+type AgentsSpanData = AgentSpanData | FunctionSpanData | GenerationSpanData | ResponseSpanData | HandoffSpanData | CustomSpanData | GuardrailSpanData | TranscriptionSpanData | SpeechSpanData | SpeechGroupSpanData | MCPListToolsSpanData;
+interface LLMOpsAgentsExporterConfig {
+  /** LLMOps server base URL (e.g. http://localhost:5177) */
+  baseURL: string;
+  /** Environment secret or API key for authentication */
+  apiKey: string;
+  /** Custom headers to include in requests */
+  headers?: Record<string, string>;
+  /** Custom fetch implementation (used internally by client.agentsExporter()) */
+  fetch?: typeof globalThis.fetch;
+}
+/**
+ * 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!,
+ *   }))
+ * ]);
+ * ```
+ */
+declare function createLLMOpsAgentsExporter(config: LLMOpsAgentsExporterConfig): AgentsTracingExporter;
+//#endregion
+export { AgentsTracingExporter as a, AgentsTrace as i, AgentsSpanData as n, LLMOpsAgentsExporterConfig as o, AgentsSpanError as r, createLLMOpsAgentsExporter as s, AgentsSpan as t };

package/dist/agents.cjs

@@ -0,0 +1,3 @@
+const require_agents_exporter = require('./agents-exporter-Ct3l12qS.cjs');
+
+exports.createLLMOpsAgentsExporter = require_agents_exporter.createLLMOpsAgentsExporter;

package/dist/agents.d.cts

@@ -0,0 +1,2 @@
+import { a as AgentsTracingExporter, i as AgentsTrace, n as AgentsSpanData, o as LLMOpsAgentsExporterConfig, r as AgentsSpanError, s as createLLMOpsAgentsExporter, t as AgentsSpan } from "./agents-exporter-DvECkYQd.cjs";
+export { AgentsSpan, AgentsSpanData, AgentsSpanError, AgentsTrace, AgentsTracingExporter, LLMOpsAgentsExporterConfig, createLLMOpsAgentsExporter };

package/dist/agents.d.mts

@@ -0,0 +1,2 @@
+import { a as AgentsTracingExporter, i as AgentsTrace, n as AgentsSpanData, o as LLMOpsAgentsExporterConfig, r as AgentsSpanError, s as createLLMOpsAgentsExporter, t as AgentsSpan } from "./agents-exporter-DIoxRgjd.mjs";
+export { AgentsSpan, AgentsSpanData, AgentsSpanError, AgentsTrace, AgentsTracingExporter, LLMOpsAgentsExporterConfig, createLLMOpsAgentsExporter };

package/dist/agents.mjs

@@ -0,0 +1,3 @@
+import { t as createLLMOpsAgentsExporter } from "./agents-exporter-BorGCb93.mjs";
+
+export { createLLMOpsAgentsExporter };

package/dist/express.d.cts

@@ -1,3 +1,4 @@
-import "./index-De3QdpKX.cjs";
-import { t as createLLMOpsMiddleware } from "./index-CHeoSGK0.cjs";
+import "./agents-exporter-DvECkYQd.cjs";
+import "./index-D49MVTAo.cjs";
+import { t as createLLMOpsMiddleware } from "./index-DVTO0Hbl.cjs";
 export { createLLMOpsMiddleware };

package/dist/express.d.mts

@@ -1,3 +1,4 @@
-import "./index-BkLZoEW_.mjs";
-import { t as createLLMOpsMiddleware } from "./index-bdFT7Yxj.mjs";
+import "./agents-exporter-DIoxRgjd.mjs";
+import "./index-CelQx4B3.mjs";
+import { t as createLLMOpsMiddleware } from "./index-CmC2x4dU.mjs";
 export { createLLMOpsMiddleware };

package/dist/express.mjs

@@ -1,3 +1,3 @@
-import { t as createLLMOpsMiddleware } from "./express-Dz3xwxkh.mjs";
+import { t as createLLMOpsMiddleware } from "./express-ClEIbLM9.mjs";
 
 export { createLLMOpsMiddleware };

package/dist/hono.d.cts

@@ -1,4 +1,5 @@
-import { t as LLMOpsClient } from "./index-De3QdpKX.cjs";
+import "./agents-exporter-DvECkYQd.cjs";
+import { t as LLMOpsClient } from "./index-D49MVTAo.cjs";
 import { MiddlewareHandler } from "hono";
 
 //#region src/lib/hono/index.d.ts

package/dist/hono.d.mts

@@ -1,4 +1,5 @@
-import { t as LLMOpsClient } from "./index-BkLZoEW_.mjs";
+import "./agents-exporter-DIoxRgjd.mjs";
+import { t as LLMOpsClient } from "./index-CelQx4B3.mjs";
 import { MiddlewareHandler } from "hono";
 
 //#region src/lib/hono/index.d.ts

package/dist/index-CelQx4B3.d.mts

@@ -0,0 +1,26 @@
+import { a as AgentsTracingExporter } from "./agents-exporter-DIoxRgjd.mjs";
+import { LLMOpsConfig, ValidatedLLMOpsConfig } from "@llmops/core";
+
+//#region src/client/index.d.ts
+type ProviderConfig = {
+  baseURL: string;
+  apiKey: string;
+  fetch: typeof globalThis.fetch;
+};
+type TraceContext = {
+  traceId?: string;
+  spanName?: string;
+  traceName?: string;
+};
+type ProviderOptions = {
+  traceContext?: () => TraceContext | null;
+};
+type LLMOpsClient = {
+  handler: (request: Request) => Promise<Response>;
+  config: ValidatedLLMOpsConfig;
+  provider: (options?: ProviderOptions) => ProviderConfig;
+  agentsExporter: () => AgentsTracingExporter;
+};
+declare const createLLMOps: (config?: LLMOpsConfig) => LLMOpsClient;
+//#endregion
+export { createLLMOps as i, ProviderOptions as n, TraceContext as r, LLMOpsClient as t };

package/dist/{index-bdFT7Yxj.d.mts → index-CmC2x4dU.d.mts}

@@ -1,4 +1,4 @@
-import { t as LLMOpsClient } from "./index-BkLZoEW_.mjs";
+import { t as LLMOpsClient } from "./index-CelQx4B3.mjs";
 import { NextFunction, Request, Response } from "express";
 
 //#region src/lib/express/index.d.ts

package/dist/index-D49MVTAo.d.cts

@@ -0,0 +1,26 @@
+import { a as AgentsTracingExporter } from "./agents-exporter-DvECkYQd.cjs";
+import { LLMOpsConfig, ValidatedLLMOpsConfig } from "@llmops/core";
+
+//#region src/client/index.d.ts
+type ProviderConfig = {
+  baseURL: string;
+  apiKey: string;
+  fetch: typeof globalThis.fetch;
+};
+type TraceContext = {
+  traceId?: string;
+  spanName?: string;
+  traceName?: string;
+};
+type ProviderOptions = {
+  traceContext?: () => TraceContext | null;
+};
+type LLMOpsClient = {
+  handler: (request: Request) => Promise<Response>;
+  config: ValidatedLLMOpsConfig;
+  provider: (options?: ProviderOptions) => ProviderConfig;
+  agentsExporter: () => AgentsTracingExporter;
+};
+declare const createLLMOps: (config?: LLMOpsConfig) => LLMOpsClient;
+//#endregion
+export { createLLMOps as i, ProviderOptions as n, TraceContext as r, LLMOpsClient as t };

package/dist/{index-CHeoSGK0.d.cts → index-DVTO0Hbl.d.cts}

@@ -1,4 +1,4 @@
-import { t as LLMOpsClient } from "./index-De3QdpKX.cjs";
+import { t as LLMOpsClient } from "./index-D49MVTAo.cjs";
 import { NextFunction, Request, Response } from "express";
 
 //#region src/lib/express/index.d.ts

package/dist/index.cjs

@@ -1,5 +1,6 @@
 const require_express = require('./express-B-wbCza5.cjs');
-require("@llmops/core");
+const require_agents_exporter = require('./agents-exporter-Ct3l12qS.cjs');
+let __llmops_core = require("@llmops/core");
 let __llmops_app = require("@llmops/app");
 
 //#region src/lib/auth/client.ts
@@ -19,24 +20,166 @@ const createLLMOps = (config) => {
 	const { app, config: validatedConfig } = (0, __llmops_app.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_core.LLMOPS_TRACE_ID_HEADER, ctx.traceId);
+					if (ctx.traceName) headers.set(__llmops_core.LLMOPS_TRACE_NAME_HEADER, ctx.traceName);
+					if (ctx.spanName) headers.set(__llmops_core.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)
+		}),
+		agentsExporter: () => require_agents_exporter.createLLMOpsAgentsExporter({
+			baseURL: `http://localhost${basePath}`,
+			apiKey: "llmops",
+			fetch: createInternalFetch()
 		})
 	};
 };
 
+//#endregion
+//#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(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) };
+}
+/**
+* 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(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(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(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
 exports.AuthFeatureNotAvailableError = AuthFeatureNotAvailableError;
+exports.createLLMOpsAgentsExporter = require_agents_exporter.createLLMOpsAgentsExporter;
 exports.createLLMOpsMiddleware = require_express.createLLMOpsMiddleware;
+exports.createLLMOpsSpanExporter = createLLMOpsSpanExporter;
 exports.llmops = createLLMOps;

package/dist/index.d.cts

@@ -1,5 +1,6 @@
-import { n as createLLMOps, t as LLMOpsClient } from "./index-De3QdpKX.cjs";
-import { t as createLLMOpsMiddleware } from "./index-CHeoSGK0.cjs";
+import { a as AgentsTracingExporter, o as LLMOpsAgentsExporterConfig, s as createLLMOpsAgentsExporter } from "./agents-exporter-DvECkYQd.cjs";
+import { i as createLLMOps, n as ProviderOptions, r as TraceContext, t as LLMOpsClient } from "./index-D49MVTAo.cjs";
+import { t as createLLMOpsMiddleware } from "./index-DVTO0Hbl.cjs";
 
 //#region src/lib/auth/client.d.ts
 
@@ -170,4 +171,93 @@ declare class AuthFeatureNotAvailableError extends Error {
   constructor(feature: string, authType: string);
 }
 //#endregion
-export { AuthClient, AuthFeatureNotAvailableError, type LLMOpsClient, PaginatedResponse, PaginationOptions, Permission, Session, User, createLLMOpsMiddleware, createLLMOps as llmops };
+//#region src/telemetry/exporter.d.ts
+/**
+ * LLMOps OTLP Span Exporter
+ *
+ * A lightweight OTel SpanExporter that sends spans to the LLMOps server's
+ * OTLP ingestion endpoint. Compatible with OpenTelemetry SDK.
+ *
+ * @example
+ * ```typescript
+ * import { createLLMOpsSpanExporter } from '@llmops/sdk/telemetry';
+ * import { NodeTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
+ *
+ * const provider = new NodeTracerProvider();
+ * provider.addSpanProcessor(
+ *   new SimpleSpanProcessor(createLLMOpsSpanExporter({
+ *     baseURL: process.env.LLMOPS_URL,
+ *     apiKey: process.env.LLMOPS_API_KEY,
+ *   }))
+ * );
+ * provider.register();
+ *
+ * // Now Vercel AI SDK spans automatically flow to LLMOps
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello',
+ *   experimental_telemetry: { isEnabled: true },
+ * });
+ * ```
+ */
+/**
+ * Minimal OTel SpanExporter interface
+ * We don't depend on @opentelemetry/sdk-trace-base — just implement the interface
+ */
+interface SpanExporter {
+  export(spans: ReadonlyArray<ReadableSpan>, resultCallback: (result: ExportResult) => void): void;
+  shutdown(): Promise<void>;
+  forceFlush?(): Promise<void>;
+}
+/** Subset of OTel ReadableSpan we consume */
+interface ReadableSpan {
+  readonly spanContext: () => {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+  };
+  readonly parentSpanId?: string;
+  readonly name: string;
+  readonly kind: number;
+  readonly startTime: [number, number];
+  readonly endTime: [number, number];
+  readonly status: {
+    code: number;
+    message?: string;
+  };
+  readonly attributes: Record<string, unknown>;
+  readonly events: ReadonlyArray<{
+    name: string;
+    time: [number, number];
+    attributes?: Record<string, unknown>;
+  }>;
+  readonly resource: {
+    attributes: Record<string, unknown>;
+  };
+  readonly instrumentationLibrary: {
+    name: string;
+    version?: string;
+  };
+}
+interface ExportResult {
+  code: ExportResultCode;
+  error?: Error;
+}
+declare enum ExportResultCode {
+  SUCCESS = 0,
+  FAILED = 1,
+}
+interface LLMOpsExporterConfig {
+  /** LLMOps server base URL (e.g. http://localhost:3000) */
+  baseURL: string;
+  /** Environment secret or API key for authentication */
+  apiKey: string;
+  /** Custom headers to include in requests */
+  headers?: Record<string, string>;
+}
+/**
+ * Create an OTel SpanExporter that sends spans to an LLMOps server.
+ */
+declare function createLLMOpsSpanExporter(config: LLMOpsExporterConfig): SpanExporter;
+//#endregion
+export { type AgentsTracingExporter, AuthClient, AuthFeatureNotAvailableError, type LLMOpsAgentsExporterConfig, type LLMOpsClient, type LLMOpsExporterConfig, PaginatedResponse, PaginationOptions, Permission, type ProviderOptions, Session, type SpanExporter, type TraceContext, User, createLLMOpsAgentsExporter, createLLMOpsMiddleware, createLLMOpsSpanExporter, createLLMOps as llmops };

package/dist/index.d.mts

@@ -1,5 +1,6 @@
-import { n as createLLMOps, t as LLMOpsClient } from "./index-BkLZoEW_.mjs";
-import { t as createLLMOpsMiddleware } from "./index-bdFT7Yxj.mjs";
+import { a as AgentsTracingExporter, o as LLMOpsAgentsExporterConfig, s as createLLMOpsAgentsExporter } from "./agents-exporter-DIoxRgjd.mjs";
+import { i as createLLMOps, n as ProviderOptions, r as TraceContext, t as LLMOpsClient } from "./index-CelQx4B3.mjs";
+import { t as createLLMOpsMiddleware } from "./index-CmC2x4dU.mjs";
 
 //#region src/lib/auth/client.d.ts
 
@@ -170,4 +171,93 @@ declare class AuthFeatureNotAvailableError extends Error {
   constructor(feature: string, authType: string);
 }
 //#endregion
-export { AuthClient, AuthFeatureNotAvailableError, type LLMOpsClient, PaginatedResponse, PaginationOptions, Permission, Session, User, createLLMOpsMiddleware, createLLMOps as llmops };
+//#region src/telemetry/exporter.d.ts
+/**
+ * LLMOps OTLP Span Exporter
+ *
+ * A lightweight OTel SpanExporter that sends spans to the LLMOps server's
+ * OTLP ingestion endpoint. Compatible with OpenTelemetry SDK.
+ *
+ * @example
+ * ```typescript
+ * import { createLLMOpsSpanExporter } from '@llmops/sdk/telemetry';
+ * import { NodeTracerProvider, SimpleSpanProcessor } from '@opentelemetry/sdk-trace-node';
+ *
+ * const provider = new NodeTracerProvider();
+ * provider.addSpanProcessor(
+ *   new SimpleSpanProcessor(createLLMOpsSpanExporter({
+ *     baseURL: process.env.LLMOPS_URL,
+ *     apiKey: process.env.LLMOPS_API_KEY,
+ *   }))
+ * );
+ * provider.register();
+ *
+ * // Now Vercel AI SDK spans automatically flow to LLMOps
+ * const result = await generateText({
+ *   model: openai('gpt-4o'),
+ *   prompt: 'Hello',
+ *   experimental_telemetry: { isEnabled: true },
+ * });
+ * ```
+ */
+/**
+ * Minimal OTel SpanExporter interface
+ * We don't depend on @opentelemetry/sdk-trace-base — just implement the interface
+ */
+interface SpanExporter {
+  export(spans: ReadonlyArray<ReadableSpan>, resultCallback: (result: ExportResult) => void): void;
+  shutdown(): Promise<void>;
+  forceFlush?(): Promise<void>;
+}
+/** Subset of OTel ReadableSpan we consume */
+interface ReadableSpan {
+  readonly spanContext: () => {
+    traceId: string;
+    spanId: string;
+    traceFlags: number;
+  };
+  readonly parentSpanId?: string;
+  readonly name: string;
+  readonly kind: number;
+  readonly startTime: [number, number];
+  readonly endTime: [number, number];
+  readonly status: {
+    code: number;
+    message?: string;
+  };
+  readonly attributes: Record<string, unknown>;
+  readonly events: ReadonlyArray<{
+    name: string;
+    time: [number, number];
+    attributes?: Record<string, unknown>;
+  }>;
+  readonly resource: {
+    attributes: Record<string, unknown>;
+  };
+  readonly instrumentationLibrary: {
+    name: string;
+    version?: string;
+  };
+}
+interface ExportResult {
+  code: ExportResultCode;
+  error?: Error;
+}
+declare enum ExportResultCode {
+  SUCCESS = 0,
+  FAILED = 1,
+}
+interface LLMOpsExporterConfig {
+  /** LLMOps server base URL (e.g. http://localhost:3000) */
+  baseURL: string;
+  /** Environment secret or API key for authentication */
+  apiKey: string;
+  /** Custom headers to include in requests */
+  headers?: Record<string, string>;
+}
+/**
+ * Create an OTel SpanExporter that sends spans to an LLMOps server.
+ */
+declare function createLLMOpsSpanExporter(config: LLMOpsExporterConfig): SpanExporter;
+//#endregion
+export { type AgentsTracingExporter, AuthClient, AuthFeatureNotAvailableError, type LLMOpsAgentsExporterConfig, type LLMOpsClient, type LLMOpsExporterConfig, PaginatedResponse, PaginationOptions, Permission, type ProviderOptions, Session, type SpanExporter, type TraceContext, User, createLLMOpsAgentsExporter, createLLMOpsMiddleware, createLLMOpsSpanExporter, createLLMOps as llmops };