@od-oneapp/ai-platform 0.1.0

package/dist/conditions-DmQ6Y1Wt.mjs

@@ -0,0 +1,179 @@
+//#region src/sdk/stop-conditions/conditions.ts
+/**
+* Stop when step count reaches a threshold
+*
+* @example
+* ```ts
+* import { stepCountIs } from "@od-oneapp/ai-platform";
+*
+* const result = await generateText({
+*   model,
+*   prompt,
+*   maxSteps: 10,
+*   stopWhen: stepCountIs(5),
+* });
+* ```
+*/
+function stepCountIs(count) {
+	return (context) => context.stepCount >= count;
+}
+/**
+* Stop when a specific tool is called
+*
+* @example
+* ```ts
+* import { hasToolCall } from "@od-oneapp/ai-platform";
+*
+* const result = await generateText({
+*   model,
+*   prompt,
+*   tools: { submit, search, analyze },
+*   stopWhen: hasToolCall("submit"),
+* });
+* ```
+*/
+function hasToolCall(toolName) {
+	const toolNames = Array.isArray(toolName) ? toolName : [toolName];
+	return (context) => {
+		if (!context.toolCalls) return false;
+		return context.toolCalls.some((call) => toolNames.includes(call.toolName));
+	};
+}
+/**
+* Stop when no tools are called (model finished reasoning)
+*
+* @example
+* ```ts
+* import { noToolCalls } from "@od-oneapp/ai-platform";
+*
+* const result = await generateText({
+*   model,
+*   prompt,
+*   tools: { search, analyze },
+*   stopWhen: noToolCalls(),
+* });
+* ```
+*/
+function noToolCalls() {
+	return (context) => {
+		return !context.toolCalls || context.toolCalls.length === 0;
+	};
+}
+/**
+* Stop when generated text contains a pattern
+*
+* @example
+* ```ts
+* import { textContains } from "@od-oneapp/ai-platform";
+*
+* const result = await generateText({
+*   model,
+*   prompt: "Think step by step and say DONE when finished",
+*   stopWhen: textContains(/\bDONE\b/i),
+* });
+* ```
+*/
+function textContains(pattern) {
+	const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+	return (context) => {
+		if (!context.text) return false;
+		return regex.test(context.text);
+	};
+}
+/**
+* Stop when text matches exactly
+*/
+function textEquals(text) {
+	return (context) => {
+		return context.text?.trim() === text.trim();
+	};
+}
+/**
+* Stop when text ends with a specific suffix
+*/
+function textEndsWith(suffix) {
+	return (context) => {
+		return context.text?.trimEnd().endsWith(suffix) ?? false;
+	};
+}
+/**
+* Stop when any condition is met (OR)
+*
+* @example
+* ```ts
+* import { anyOf, hasToolCall, noToolCalls } from "@od-oneapp/ai-platform";
+*
+* const result = await generateText({
+*   model,
+*   prompt,
+*   stopWhen: anyOf(hasToolCall("complete"), noToolCalls()),
+* });
+* ```
+*/
+function anyOf(...conditions) {
+	return async (context) => {
+		for (const condition of conditions) if (await condition(context)) return true;
+		return false;
+	};
+}
+/**
+* Stop when all conditions are met (AND)
+*
+* @example
+* ```ts
+* import { allOf, stepCountIs, noToolCalls } from "@od-oneapp/ai-platform";
+*
+* const result = await generateText({
+*   model,
+*   prompt,
+*   stopWhen: allOf(stepCountIs(3), noToolCalls()),
+* });
+* ```
+*/
+function allOf(...conditions) {
+	return async (context) => {
+		for (const condition of conditions) if (!await condition(context)) return false;
+		return true;
+	};
+}
+/**
+* Negate a condition
+*/
+function not(condition) {
+	return async (context) => {
+		return !await condition(context);
+	};
+}
+/**
+* Stop after a timeout (in milliseconds)
+*/
+function afterTimeout(timeoutMs) {
+	const startTime = Date.now();
+	return () => {
+		return Date.now() - startTime >= timeoutMs;
+	};
+}
+/**
+* Stop when a tool result contains specific data
+*/
+function toolResultContains(toolName, predicate) {
+	return (context) => {
+		if (!context.toolResults) return false;
+		return context.toolResults.some((result) => {
+			if (result.toolName !== toolName) return false;
+			return predicate("output" in result ? result.output : result.result);
+		});
+	};
+}
+/**
+* Stop when metadata matches a condition
+*/
+function whenMetadata(predicate) {
+	return (context) => {
+		return predicate(context.metadata || {});
+	};
+}
+
+//#endregion
+export { noToolCalls as a, textContains as c, toolResultContains as d, whenMetadata as f, hasToolCall as i, textEndsWith as l, allOf as n, not as o, anyOf as r, stepCountIs as s, afterTimeout as t, textEquals as u };
+//# sourceMappingURL=conditions-DmQ6Y1Wt.mjs.map

package/dist/conditions-DmQ6Y1Wt.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions-DmQ6Y1Wt.mjs","names":[],"sources":["../src/sdk/stop-conditions/conditions.ts"],"sourcesContent":["/**\n * Predefined stop conditions for agentic loops\n *\n * These utilities align with Vercel AI SDK v6 stopWhen patterns\n */\n\nimport type { StopCondition, StopConditionContext } from './types';\n\n/**\n * Stop when step count reaches a threshold\n *\n * @example\n * ```ts\n * import { stepCountIs } from \"@od-oneapp/ai-platform\";\n *\n * const result = await generateText({\n *   model,\n *   prompt,\n *   maxSteps: 10,\n *   stopWhen: stepCountIs(5),\n * });\n * ```\n */\nexport function stepCountIs(count: number): StopCondition {\n  return (context: StopConditionContext) => context.stepCount >= count;\n}\n\n/**\n * Stop when a specific tool is called\n *\n * @example\n * ```ts\n * import { hasToolCall } from \"@od-oneapp/ai-platform\";\n *\n * const result = await generateText({\n *   model,\n *   prompt,\n *   tools: { submit, search, analyze },\n *   stopWhen: hasToolCall(\"submit\"),\n * });\n * ```\n */\nexport function hasToolCall(toolName: string | string[]): StopCondition {\n  const toolNames = Array.isArray(toolName) ? toolName : [toolName];\n\n  return (context: StopConditionContext) => {\n    if (!context.toolCalls) return false;\n    return context.toolCalls.some(call => toolNames.includes(call.toolName));\n  };\n}\n\n/**\n * Stop when no tools are called (model finished reasoning)\n *\n * @example\n * ```ts\n * import { noToolCalls } from \"@od-oneapp/ai-platform\";\n *\n * const result = await generateText({\n *   model,\n *   prompt,\n *   tools: { search, analyze },\n *   stopWhen: noToolCalls(),\n * });\n * ```\n */\nexport function noToolCalls(): StopCondition {\n  return (context: StopConditionContext) => {\n    return !context.toolCalls || context.toolCalls.length === 0;\n  };\n}\n\n/**\n * Stop when generated text contains a pattern\n *\n * @example\n * ```ts\n * import { textContains } from \"@od-oneapp/ai-platform\";\n *\n * const result = await generateText({\n *   model,\n *   prompt: \"Think step by step and say DONE when finished\",\n *   stopWhen: textContains(/\\bDONE\\b/i),\n * });\n * ```\n */\nexport function textContains(pattern: RegExp | string): StopCondition {\n  const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;\n\n  return (context: StopConditionContext) => {\n    if (!context.text) return false;\n    return regex.test(context.text);\n  };\n}\n\n/**\n * Stop when text matches exactly\n */\nexport function textEquals(text: string): StopCondition {\n  return (context: StopConditionContext) => {\n    return context.text?.trim() === text.trim();\n  };\n}\n\n/**\n * Stop when text ends with a specific suffix\n */\nexport function textEndsWith(suffix: string): StopCondition {\n  return (context: StopConditionContext) => {\n    return context.text?.trimEnd().endsWith(suffix) ?? false;\n  };\n}\n\n/**\n * Stop when any condition is met (OR)\n *\n * @example\n * ```ts\n * import { anyOf, hasToolCall, noToolCalls } from \"@od-oneapp/ai-platform\";\n *\n * const result = await generateText({\n *   model,\n *   prompt,\n *   stopWhen: anyOf(hasToolCall(\"complete\"), noToolCalls()),\n * });\n * ```\n */\nexport function anyOf(...conditions: StopCondition[]): StopCondition {\n  return async (context: StopConditionContext) => {\n    for (const condition of conditions) {\n      const result = await condition(context);\n      if (result) return true;\n    }\n    return false;\n  };\n}\n\n/**\n * Stop when all conditions are met (AND)\n *\n * @example\n * ```ts\n * import { allOf, stepCountIs, noToolCalls } from \"@od-oneapp/ai-platform\";\n *\n * const result = await generateText({\n *   model,\n *   prompt,\n *   stopWhen: allOf(stepCountIs(3), noToolCalls()),\n * });\n * ```\n */\nexport function allOf(...conditions: StopCondition[]): StopCondition {\n  return async (context: StopConditionContext) => {\n    for (const condition of conditions) {\n      const result = await condition(context);\n      if (!result) return false;\n    }\n    return true;\n  };\n}\n\n/**\n * Negate a condition\n */\nexport function not(condition: StopCondition): StopCondition {\n  return async (context: StopConditionContext) => {\n    return !(await condition(context));\n  };\n}\n\n/**\n * Stop after a timeout (in milliseconds)\n */\nexport function afterTimeout(timeoutMs: number): StopCondition {\n  const startTime = Date.now();\n\n  return () => {\n    return Date.now() - startTime >= timeoutMs;\n  };\n}\n\n/**\n * Stop when a tool result contains specific data\n */\nexport function toolResultContains(\n  toolName: string,\n  predicate: (result: unknown) => boolean,\n): StopCondition {\n  return (context: StopConditionContext) => {\n    if (!context.toolResults) return false;\n\n    return context.toolResults.some(result => {\n      if (result.toolName !== toolName) return false;\n      const payload = 'output' in result ? result.output : (result as { result?: unknown }).result;\n      return predicate(payload);\n    });\n  };\n}\n\n/**\n * Stop when metadata matches a condition\n */\nexport function whenMetadata(\n  predicate: (metadata: Record<string, unknown>) => boolean,\n): StopCondition {\n  return (context: StopConditionContext) => {\n    return predicate(context.metadata || {});\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAuBA,SAAgB,YAAY,OAA8B;AACxD,SAAQ,YAAkC,QAAQ,aAAa;;;;;;;;;;;;;;;;;AAkBjE,SAAgB,YAAY,UAA4C;CACtE,MAAM,YAAY,MAAM,QAAQ,SAAS,GAAG,WAAW,CAAC,SAAS;AAEjE,SAAQ,YAAkC;AACxC,MAAI,CAAC,QAAQ,UAAW,QAAO;AAC/B,SAAO,QAAQ,UAAU,MAAK,SAAQ,UAAU,SAAS,KAAK,SAAS,CAAC;;;;;;;;;;;;;;;;;;AAmB5E,SAAgB,cAA6B;AAC3C,SAAQ,YAAkC;AACxC,SAAO,CAAC,QAAQ,aAAa,QAAQ,UAAU,WAAW;;;;;;;;;;;;;;;;;AAkB9D,SAAgB,aAAa,SAAyC;CACpE,MAAM,QAAQ,OAAO,YAAY,WAAW,IAAI,OAAO,QAAQ,GAAG;AAElE,SAAQ,YAAkC;AACxC,MAAI,CAAC,QAAQ,KAAM,QAAO;AAC1B,SAAO,MAAM,KAAK,QAAQ,KAAK;;;;;;AAOnC,SAAgB,WAAW,MAA6B;AACtD,SAAQ,YAAkC;AACxC,SAAO,QAAQ,MAAM,MAAM,KAAK,KAAK,MAAM;;;;;;AAO/C,SAAgB,aAAa,QAA+B;AAC1D,SAAQ,YAAkC;AACxC,SAAO,QAAQ,MAAM,SAAS,CAAC,SAAS,OAAO,IAAI;;;;;;;;;;;;;;;;;AAkBvD,SAAgB,MAAM,GAAG,YAA4C;AACnE,QAAO,OAAO,YAAkC;AAC9C,OAAK,MAAM,aAAa,WAEtB,KADe,MAAM,UAAU,QAAQ,CAC3B,QAAO;AAErB,SAAO;;;;;;;;;;;;;;;;;AAkBX,SAAgB,MAAM,GAAG,YAA4C;AACnE,QAAO,OAAO,YAAkC;AAC9C,OAAK,MAAM,aAAa,WAEtB,KAAI,CADW,MAAM,UAAU,QAAQ,CAC1B,QAAO;AAEtB,SAAO;;;;;;AAOX,SAAgB,IAAI,WAAyC;AAC3D,QAAO,OAAO,YAAkC;AAC9C,SAAO,CAAE,MAAM,UAAU,QAAQ;;;;;;AAOrC,SAAgB,aAAa,WAAkC;CAC7D,MAAM,YAAY,KAAK,KAAK;AAE5B,cAAa;AACX,SAAO,KAAK,KAAK,GAAG,aAAa;;;;;;AAOrC,SAAgB,mBACd,UACA,WACe;AACf,SAAQ,YAAkC;AACxC,MAAI,CAAC,QAAQ,YAAa,QAAO;AAEjC,SAAO,QAAQ,YAAY,MAAK,WAAU;AACxC,OAAI,OAAO,aAAa,SAAU,QAAO;AAEzC,UAAO,UADS,YAAY,SAAS,OAAO,SAAU,OAAgC,OAC7D;IACzB;;;;;;AAON,SAAgB,aACd,WACe;AACf,SAAQ,YAAkC;AACxC,SAAO,UAAU,QAAQ,YAAY,EAAE,CAAC"}

package/dist/conditions-zDrKfrc3.d.mts

@@ -0,0 +1,42 @@
+import { Zi as SDKToolCallPart, la as SDKToolResultPart } from "./ai-runtime-DIwOEc6g.mjs";
+
+//#region src/sdk/stop-conditions/types.d.ts
+interface StopConditionContext {
+  stepCount: number;
+  maxSteps: number;
+  toolCalls?: SDKToolCallPart[];
+  toolResults?: SDKToolResultPart[];
+  text?: string;
+  response?: unknown;
+  metadata?: Record<string, unknown>;
+}
+type StopCondition = (context: StopConditionContext) => boolean | Promise<boolean>;
+interface StopConditionResult {
+  shouldStop: boolean;
+  reason?: string;
+  condition?: string;
+}
+interface StopConditionOptions {
+  maxSteps?: number;
+  stopOnToolCall?: string | string[];
+  stopOnNoToolCalls?: boolean;
+  stopOnTextPattern?: RegExp | string;
+  customConditions?: StopCondition[];
+}
+//#endregion
+//#region src/sdk/stop-conditions/conditions.d.ts
+declare function stepCountIs(count: number): StopCondition;
+declare function hasToolCall(toolName: string | string[]): StopCondition;
+declare function noToolCalls(): StopCondition;
+declare function textContains(pattern: RegExp | string): StopCondition;
+declare function textEquals(text: string): StopCondition;
+declare function textEndsWith(suffix: string): StopCondition;
+declare function anyOf(...conditions: StopCondition[]): StopCondition;
+declare function allOf(...conditions: StopCondition[]): StopCondition;
+declare function not(condition: StopCondition): StopCondition;
+declare function afterTimeout(timeoutMs: number): StopCondition;
+declare function toolResultContains(toolName: string, predicate: (result: unknown) => boolean): StopCondition;
+declare function whenMetadata(predicate: (metadata: Record<string, unknown>) => boolean): StopCondition;
+//#endregion
+export { noToolCalls as a, textContains as c, toolResultContains as d, whenMetadata as f, StopConditionResult as g, StopConditionOptions as h, hasToolCall as i, textEndsWith as l, StopConditionContext as m, allOf as n, not as o, StopCondition as p, anyOf as r, stepCountIs as s, afterTimeout as t, textEquals as u };
+//# sourceMappingURL=conditions-zDrKfrc3.d.mts.map

package/dist/conditions-zDrKfrc3.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions-zDrKfrc3.d.mts","names":[],"sources":["../src/sdk/stop-conditions/types.ts","../src/sdk/stop-conditions/conditions.ts"],"mappings":";;;UASiB,oBAAA;EAEf,SAAA;EAEA,QAAA;EAEA,SAAA,GAAY,eAAA;EAEZ,WAAA,GAAc,iBAAA;EAEd,IAAA;EAEA,QAAA;EAEA,QAAA,GAAW,MAAA;AAAA;AAAA,KAOD,aAAA,IAAiB,OAAA,EAAS,oBAAA,eAAmC,OAAA;AAAA,UAKxD,mBAAA;EAEf,UAAA;EAEA,MAAA;EAEA,SAAA;AAAA;AAAA,UAMe,oBAAA;EAEf,QAAA;EAEA,cAAA;EAEA,iBAAA;EAEA,iBAAA,GAAoB,MAAA;EAEpB,gBAAA,GAAmB,aAAA;AAAA;;;iBClCL,WAAA,CAAY,KAAA,WAAgB,aAAA;AAAA,iBAmB5B,WAAA,CAAY,QAAA,sBAA8B,aAAA;AAAA,iBAwB1C,WAAA,CAAA,GAAe,aAAA;AAAA,iBAoBf,YAAA,CAAa,OAAA,EAAS,MAAA,YAAkB,aAAA;AAAA,iBAYxC,UAAA,CAAW,IAAA,WAAe,aAAA;AAAA,iBAS1B,YAAA,CAAa,MAAA,WAAiB,aAAA;AAAA,iBAoB9B,KAAA,CAAA,GAAS,UAAA,EAAY,aAAA,KAAkB,aAAA;AAAA,iBAwBvC,KAAA,CAAA,GAAS,UAAA,EAAY,aAAA,KAAkB,aAAA;AAAA,iBAavC,GAAA,CAAI,SAAA,EAAW,aAAA,GAAgB,aAAA;AAAA,iBAS/B,YAAA,CAAa,SAAA,WAAoB,aAAA;AAAA,iBAWjC,kBAAA,CACd,QAAA,UACA,SAAA,GAAY,MAAA,wBACX,aAAA;AAAA,iBAea,YAAA,CACd,SAAA,GAAY,QAAA,EAAU,MAAA,gCACrB,aAAA"}

package/dist/console-BGMxxPZN.mjs

@@ -0,0 +1,181 @@
+import { randomUUID } from "node:crypto";
+import { logError, logInfo } from "@od-oneapp/shared/logs";
+
+//#region src/observability/tracing/otel/ai-instrumentation.ts
+/**
+* AI instrumentation for OpenTelemetry
+* Compatible with Vercel AI SDK's experimental_telemetry
+*/
+/**
+* Global trace context (AsyncLocalStorage would be better in production)
+*/
+let currentContext = null;
+const getUsageTotal = (value) => {
+	if (typeof value === "number") return value;
+	if (value && typeof value === "object" && "total" in value) {
+		const { total } = value;
+		return typeof total === "number" ? total : 0;
+	}
+	return 0;
+};
+/**
+* Generate a random hex string for IDs
+*/
+function generateId(length) {
+	return randomUUID().replace(/-/g, "").slice(0, length);
+}
+/**
+* Get or create trace context
+*/
+function getTraceContext() {
+	if (!currentContext) currentContext = {
+		traceId: generateId(32),
+		spanId: generateId(16)
+	};
+	return currentContext;
+}
+/**
+* Set trace context (for propagation from headers)
+*/
+function setTraceContext(context) {
+	currentContext = context;
+}
+/**
+* Create a new span
+*/
+function createSpan(name, attributes = {}) {
+	const context = getTraceContext();
+	const parentSpanId = context.spanId;
+	const spanId = generateId(16);
+	currentContext = {
+		...context,
+		spanId
+	};
+	return {
+		spanId,
+		parentSpanId,
+		traceId: context.traceId,
+		name,
+		startTime: Date.now(),
+		endTime: 0,
+		status: "ok",
+		attributes
+	};
+}
+/**
+* End a span and export it
+*/
+async function endSpan(span, config, error) {
+	span.endTime = Date.now();
+	if (error) {
+		span.status = "error";
+		span.error = error.message;
+	}
+	if (config.sampleRate !== void 0 && Math.random() > config.sampleRate) return;
+	await Promise.all(config.exporters.map((exporter) => Promise.resolve().then(() => exporter.exportSpan(span)).catch((err) => logError(`[Tracing] Export error (${exporter.name})`, { error: err instanceof Error ? err : new Error(String(err)) }))));
+}
+/**
+* Setup AI instrumentation
+* Returns telemetry config compatible with Vercel AI SDK
+*
+* @example
+* ```ts
+* import { experimental_telemetry } from "ai";
+*
+* const telemetry = await setupAIInstrumentation({
+*   serviceName: "my-ai-app",
+*   exporters: [langfuseExporter, axiomExporter],
+*   sampleRate: 1.0,
+* });
+*
+* const result = await generateText({
+*   model: anthropic("claude-sonnet-4-20250514"),
+*   prompt: "Hello",
+*   experimental_telemetry: telemetry,
+* });
+* ```
+*/
+async function setupAIInstrumentation(config) {
+	try {
+		await Promise.all(config.exporters.map((e) => e.init()));
+	} catch (err) {
+		logError("[Tracing] Exporter init error", { error: err instanceof Error ? err : new Error(String(err)) });
+	}
+	return {
+		isEnabled: true,
+		functionId: config.serviceName,
+		metadata: { serviceName: config.serviceName },
+		recordInputs: config.recordContent ?? false,
+		recordOutputs: config.recordContent ?? false
+	};
+}
+/**
+* Create instrumentation middleware for AI SDK
+*/
+function createTracingMiddleware(config) {
+	return {
+		specificationVersion: "v3",
+		wrapGenerate: async ({ doGenerate, params }) => {
+			const span = createSpan("ai.generate", {
+				"gen_ai.request.model": params.model,
+				"gen_ai.request.temperature": params.temperature,
+				"gen_ai.request.max_tokens": params.maxOutputTokens
+			});
+			try {
+				const result = await doGenerate();
+				const inputTokens = getUsageTotal(result.usage?.inputTokens);
+				const outputTokens = getUsageTotal(result.usage?.outputTokens);
+				if (inputTokens > 0) span.attributes["gen_ai.usage.input_tokens"] = inputTokens;
+				if (outputTokens > 0) span.attributes["gen_ai.usage.output_tokens"] = outputTokens;
+				if (result.finishReason !== void 0) span.attributes["gen_ai.response.finish_reasons"] = [String(result.finishReason)];
+				await endSpan(span, config);
+				return result;
+			} catch (error) {
+				await endSpan(span, config, error);
+				throw error;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/observability/tracing/otel/exporters/console.ts
+/**
+* Console exporter for development and debugging
+*/
+/**
+* Console exporter - logs spans to console
+* Useful for development and debugging
+*
+* @example
+* ```ts
+* const exporter = new ConsoleExporter({ pretty: true });
+* ```
+*/
+var ConsoleExporter = class {
+	name = "console";
+	pretty;
+	constructor(options = {}) {
+		this.pretty = options.pretty ?? true;
+	}
+	async init() {
+		logInfo("[ConsoleExporter] Initialized");
+	}
+	async exportSpan(span) {
+		const duration = span.endTime - span.startTime;
+		if (this.pretty) {
+			logInfo(`[Span] ${span.name} (${duration}ms) ${span.status === "error" ? "❌" : "✓"}`);
+			if (span.attributes["gen_ai.request.model"]) logInfo(`  Model: ${span.attributes["gen_ai.request.model"]}`);
+			if (span.attributes["gen_ai.usage.input_tokens"]) logInfo(`  Tokens: ${span.attributes["gen_ai.usage.input_tokens"]} in / ${span.attributes["gen_ai.usage.output_tokens"]} out`);
+			if (span.error) logInfo(`  Error: ${span.error}`);
+		} else logInfo(JSON.stringify(span));
+	}
+	async flush() {}
+	async shutdown() {
+		logInfo("[ConsoleExporter] Shutdown");
+	}
+};
+
+//#endregion
+export { getTraceContext as a, endSpan as i, createSpan as n, setTraceContext as o, createTracingMiddleware as r, setupAIInstrumentation as s, ConsoleExporter as t };
+//# sourceMappingURL=console-BGMxxPZN.mjs.map

package/dist/console-BGMxxPZN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-BGMxxPZN.mjs","names":[],"sources":["../src/observability/tracing/otel/ai-instrumentation.ts","../src/observability/tracing/otel/exporters/console.ts"],"sourcesContent":["/**\n * AI instrumentation for OpenTelemetry\n * Compatible with Vercel AI SDK's experimental_telemetry\n */\n\nimport { randomUUID } from 'node:crypto';\n\nimport { logError } from '@repo/shared/logs';\n\nimport type { WrapGenerateArgs } from '../../../sdk/middleware/model-middleware';\nimport type { SDKLanguageModelV3Middleware } from '../../../shared';\nimport type { AIInstrumentationConfig, AISpan, AISpanAttributes, TraceContext } from '../types';\n\n/**\n * Global trace context (AsyncLocalStorage would be better in production)\n */\nlet currentContext: TraceContext | null = null;\n\nconst getUsageTotal = (value: unknown): number => {\n  if (typeof value === 'number') return value;\n  if (value && typeof value === 'object' && 'total' in value) {\n    const { total } = value as { total?: unknown };\n    return typeof total === 'number' ? total : 0;\n  }\n  return 0;\n};\n\n/**\n * Generate a random hex string for IDs\n */\nfunction generateId(length: number): string {\n  return randomUUID().replace(/-/g, '').slice(0, length);\n}\n\n/**\n * Get or create trace context\n */\nexport function getTraceContext(): TraceContext {\n  if (!currentContext) {\n    currentContext = {\n      traceId: generateId(32),\n      spanId: generateId(16),\n    };\n  }\n  return currentContext;\n}\n\n/**\n * Set trace context (for propagation from headers)\n */\nexport function setTraceContext(context: TraceContext): void {\n  currentContext = context;\n}\n\n/**\n * Create a new span\n */\nexport function createSpan(name: string, attributes: Record<string, unknown> = {}): AISpan {\n  const context = getTraceContext();\n  const parentSpanId = context.spanId;\n\n  // Update current context with new span\n  const spanId = generateId(16);\n  currentContext = { ...context, spanId };\n\n  return {\n    spanId,\n    parentSpanId,\n    traceId: context.traceId,\n    name,\n    startTime: Date.now(),\n    endTime: 0,\n    status: 'ok',\n    attributes: attributes as AISpanAttributes,\n  };\n}\n\n/**\n * End a span and export it\n */\nexport async function endSpan(\n  span: AISpan,\n  config: AIInstrumentationConfig,\n  error?: Error,\n): Promise<void> {\n  span.endTime = Date.now();\n\n  if (error) {\n    span.status = 'error';\n    span.error = error.message;\n  }\n\n  // Sample check\n  if (config.sampleRate !== undefined && Math.random() > config.sampleRate) {\n    return;\n  }\n\n  // Export to all exporters\n  await Promise.all(\n    config.exporters.map(exporter =>\n      Promise.resolve()\n        .then(() => exporter.exportSpan(span))\n        .catch(err =>\n          logError(`[Tracing] Export error (${exporter.name})`, {\n            error: err instanceof Error ? err : new Error(String(err)),\n          }),\n        ),\n    ),\n  );\n}\n\n/**\n * Setup AI instrumentation\n * Returns telemetry config compatible with Vercel AI SDK\n *\n * @example\n * ```ts\n * import { experimental_telemetry } from \"ai\";\n *\n * const telemetry = await setupAIInstrumentation({\n *   serviceName: \"my-ai-app\",\n *   exporters: [langfuseExporter, axiomExporter],\n *   sampleRate: 1.0,\n * });\n *\n * const result = await generateText({\n *   model: anthropic(\"claude-sonnet-4-20250514\"),\n *   prompt: \"Hello\",\n *   experimental_telemetry: telemetry,\n * });\n * ```\n */\nexport async function setupAIInstrumentation(config: AIInstrumentationConfig) {\n  // Initialize all exporters\n  try {\n    await Promise.all(config.exporters.map(e => e.init()));\n  } catch (err) {\n    logError('[Tracing] Exporter init error', {\n      error: err instanceof Error ? err : new Error(String(err)),\n    });\n    // Continue with degraded config - initialization failures are logged but don't block setup\n  }\n\n  return {\n    isEnabled: true,\n    functionId: config.serviceName,\n    metadata: {\n      serviceName: config.serviceName,\n    },\n    recordInputs: config.recordContent ?? false,\n    recordOutputs: config.recordContent ?? false,\n  };\n}\n\n/**\n * Create instrumentation middleware for AI SDK\n */\nexport function createTracingMiddleware(\n  config: AIInstrumentationConfig,\n): SDKLanguageModelV3Middleware {\n  return {\n    specificationVersion: 'v3',\n    wrapGenerate: async ({ doGenerate, params }: WrapGenerateArgs) => {\n      const span = createSpan('ai.generate', {\n        'gen_ai.request.model': (params as Record<string, unknown>).model,\n        'gen_ai.request.temperature': (params as Record<string, unknown>).temperature,\n        'gen_ai.request.max_tokens': (params as Record<string, unknown>).maxOutputTokens,\n      });\n\n      try {\n        const result = await doGenerate();\n\n        const inputTokens = getUsageTotal(result.usage?.inputTokens);\n        const outputTokens = getUsageTotal(result.usage?.outputTokens);\n        if (inputTokens > 0) {\n          span.attributes['gen_ai.usage.input_tokens'] = inputTokens;\n        }\n        if (outputTokens > 0) {\n          span.attributes['gen_ai.usage.output_tokens'] = outputTokens;\n        }\n        if (result.finishReason !== undefined) {\n          span.attributes['gen_ai.response.finish_reasons'] = [String(result.finishReason)];\n        }\n\n        await endSpan(span, config);\n        return result;\n      } catch (error) {\n        await endSpan(span, config, error as Error);\n        throw error;\n      }\n    },\n  };\n}\n","/**\n * Console exporter for development and debugging\n */\n\nimport { logInfo } from '@repo/shared/logs';\n\nimport type { TelemetryExporter, AISpan } from '../../types';\n\n/**\n * Console exporter - logs spans to console\n * Useful for development and debugging\n *\n * @example\n * ```ts\n * const exporter = new ConsoleExporter({ pretty: true });\n * ```\n */\nexport class ConsoleExporter implements TelemetryExporter {\n  name = 'console';\n  private pretty: boolean;\n\n  constructor(options: { pretty?: boolean } = {}) {\n    this.pretty = options.pretty ?? true;\n  }\n\n  async init(): Promise<void> {\n    logInfo('[ConsoleExporter] Initialized');\n  }\n\n  async exportSpan(span: AISpan): Promise<void> {\n    const duration = span.endTime - span.startTime;\n\n    if (this.pretty) {\n      logInfo(`[Span] ${span.name} (${duration}ms) ${span.status === 'error' ? '❌' : '✓'}`);\n      if (span.attributes['gen_ai.request.model']) {\n        logInfo(`  Model: ${span.attributes['gen_ai.request.model']}`);\n      }\n      if (span.attributes['gen_ai.usage.input_tokens']) {\n        logInfo(\n          `  Tokens: ${span.attributes['gen_ai.usage.input_tokens']} in / ${span.attributes['gen_ai.usage.output_tokens']} out`,\n        );\n      }\n      if (span.error) {\n        logInfo(`  Error: ${span.error}`);\n      }\n    } else {\n      logInfo(JSON.stringify(span));\n    }\n  }\n\n  async flush(): Promise<void> {\n    // Console doesn't buffer\n  }\n\n  async shutdown(): Promise<void> {\n    logInfo('[ConsoleExporter] Shutdown');\n  }\n}\n"],"mappings":"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"}

package/dist/console-DqEqZd4A.d.mts

@@ -0,0 +1,76 @@
+import { Ur as SDKLanguageModelV3Middleware } from "./ai-runtime-DIwOEc6g.mjs";
+
+//#region src/observability/tracing/types.d.ts
+interface TelemetryExporter {
+  name: string;
+  init(): Promise<void>;
+  exportSpan(span: AISpan): Promise<void>;
+  flush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+interface AISpan {
+  spanId: string;
+  parentSpanId?: string;
+  traceId: string;
+  name: string;
+  startTime: number;
+  endTime: number;
+  status: 'ok' | 'error';
+  error?: string;
+  attributes: AISpanAttributes;
+}
+interface AISpanAttributes {
+  'gen_ai.request.model'?: string;
+  'gen_ai.system'?: string;
+  'gen_ai.usage.input_tokens'?: number;
+  'gen_ai.usage.output_tokens'?: number;
+  'gen_ai.request.temperature'?: number;
+  'gen_ai.request.max_tokens'?: number;
+  'gen_ai.response.finish_reasons'?: string[];
+  'user.id'?: string;
+  'session.id'?: string;
+  [key: string]: unknown;
+}
+interface TraceContext {
+  traceId: string;
+  spanId: string;
+  traceFlags?: number;
+}
+interface AIInstrumentationConfig {
+  serviceName: string;
+  exporters: TelemetryExporter[];
+  sampleRate?: number;
+  recordContent?: boolean;
+}
+//#endregion
+//#region src/observability/tracing/otel/ai-instrumentation.d.ts
+declare function getTraceContext(): TraceContext;
+declare function setTraceContext(context: TraceContext): void;
+declare function createSpan(name: string, attributes?: Record<string, unknown>): AISpan;
+declare function endSpan(span: AISpan, config: AIInstrumentationConfig, error?: Error): Promise<void>;
+declare function setupAIInstrumentation(config: AIInstrumentationConfig): Promise<{
+  isEnabled: boolean;
+  functionId: string;
+  metadata: {
+    serviceName: string;
+  };
+  recordInputs: boolean;
+  recordOutputs: boolean;
+}>;
+declare function createTracingMiddleware(config: AIInstrumentationConfig): SDKLanguageModelV3Middleware;
+//#endregion
+//#region src/observability/tracing/otel/exporters/console.d.ts
+declare class ConsoleExporter implements TelemetryExporter {
+  name: string;
+  private pretty;
+  constructor(options?: {
+    pretty?: boolean;
+  });
+  init(): Promise<void>;
+  exportSpan(span: AISpan): Promise<void>;
+  flush(): Promise<void>;
+  shutdown(): Promise<void>;
+}
+//#endregion
+export { getTraceContext as a, AIInstrumentationConfig as c, TelemetryExporter as d, TraceContext as f, endSpan as i, AISpan as l, createSpan as n, setTraceContext as o, createTracingMiddleware as r, setupAIInstrumentation as s, ConsoleExporter as t, AISpanAttributes as u };
+//# sourceMappingURL=console-DqEqZd4A.d.mts.map

package/dist/console-DqEqZd4A.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-DqEqZd4A.d.mts","names":[],"sources":["../src/observability/tracing/types.ts","../src/observability/tracing/otel/ai-instrumentation.ts","../src/observability/tracing/otel/exporters/console.ts"],"mappings":";;;UAOiB,iBAAA;EAEf,IAAA;EAEA,IAAA,IAAQ,OAAA;EAER,UAAA,CAAW,IAAA,EAAM,MAAA,GAAS,OAAA;EAE1B,KAAA,IAAS,OAAA;EAET,QAAA,IAAY,OAAA;AAAA;AAAA,UAMG,MAAA;EAEf,MAAA;EAEA,YAAA;EAEA,OAAA;EAEA,IAAA;EAEA,SAAA;EAEA,OAAA;EAEA,MAAA;EAEA,KAAA;EAEA,UAAA,EAAY,gBAAA;AAAA;AAAA,UAMG,gBAAA;EAEf,sBAAA;EAEA,eAAA;EAEA,2BAAA;EAEA,4BAAA;EAEA,4BAAA;EAEA,2BAAA;EAEA,gCAAA;EAEA,SAAA;EAEA,YAAA;EAAA,CAEC,GAAA;AAAA;AAAA,UAMc,YAAA;EACf,OAAA;EACA,MAAA;EACA,UAAA;AAAA;AAAA,UAMe,uBAAA;EAEf,WAAA;EAEA,SAAA,EAAW,iBAAA;EAEX,UAAA;EAEA,aAAA;AAAA;;;iBCrDc,eAAA,CAAA,GAAmB,YAAA;AAAA,iBAanB,eAAA,CAAgB,OAAA,EAAS,YAAA;AAAA,iBAOzB,UAAA,CAAW,IAAA,UAAc,UAAA,GAAY,MAAA,oBAA+B,MAAA;AAAA,iBAuB9D,OAAA,CACpB,IAAA,EAAM,MAAA,EACN,MAAA,EAAQ,uBAAA,EACR,KAAA,GAAQ,KAAA,GACP,OAAA;AAAA,iBAgDmB,sBAAA,CAAuB,MAAA,EAAQ,uBAAA,GAAuB,OAAA;;;;;;;;;iBAyB5D,uBAAA,CACd,MAAA,EAAQ,uBAAA,GACP,4BAAA;;;cC9IU,eAAA,YAA2B,iBAAA;EACtC,IAAA;EAAA,QACQ,MAAA;cAEI,OAAA;IAAW,MAAA;EAAA;EAIjB,IAAA,CAAA,GAAQ,OAAA;EAIR,UAAA,CAAW,IAAA,EAAM,MAAA,GAAS,OAAA;EAqB1B,KAAA,CAAA,GAAS,OAAA;EAIT,QAAA,CAAA,GAAY,OAAA;AAAA"}