@agentuity/runtime 1.0.24 → 1.0.26

package/src/dev-patches/aisdk.ts

@@ -0,0 +1,172 @@
+/**
+ * Runtime AI SDK patches for dev mode.
+ *
+ * Replaces the build-time patches from cli/src/cmd/build/patch/aisdk.ts.
+ * Monkey-patches Vercel AI SDK functions to:
+ * 1. Enable experimental telemetry on all AI function calls
+ * 2. Route AI SDK provider factory functions through the AI Gateway
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+function warnMissingKey(envKey: string): void {
+	const isDev =
+		process.env.AGENTUITY_ENVIRONMENT === 'development' || process.env.NODE_ENV !== 'production';
+	if (isDev) {
+		console.error('[ERROR] No credentials found for this AI provider. To fix this, either:');
+		console.error(
+			'  1. Login to Agentuity Cloud (agentuity auth login) to use the AI Gateway (recommended)'
+		);
+		console.error(`  2. Set ${envKey} in your .env file to use the provider directly`);
+	} else {
+		console.error(`[ERROR] The environment variable ${envKey} is required. Either:`);
+		console.error(
+			'  1. Use Agentuity Cloud AI Gateway by ensuring AGENTUITY_SDK_KEY is configured'
+		);
+		console.error(`  2. Set ${envKey} using "agentuity env set ${envKey}" and redeploy`);
+	}
+}
+
+/**
+ * Wrap an AI SDK function to inject experimental_telemetry: { isEnabled: true }.
+ */
+function wrapWithTelemetry(originalFn: (...args: any[]) => any): (...args: any[]) => any {
+	return function (this: any, ...args: any[]) {
+		const opts = { ...(args[0] ?? {}) };
+		opts.experimental_telemetry = { isEnabled: true };
+		args[0] = opts;
+		return originalFn.apply(this, args);
+	};
+}
+
+/**
+ * Wrap a provider factory function (e.g., createOpenAI) to inject gateway config.
+ */
+function wrapProviderFactory(
+	originalFn: (...args: any[]) => any,
+	envKey: string,
+	provider: string
+): (...args: any[]) => any {
+	return function (this: any, ...args: any[]) {
+		const currentKey = process.env[envKey];
+		const sdkKey = process.env.AGENTUITY_SDK_KEY;
+
+		// If user provided their own key (and it's not the SDK key), leave it alone
+		if (currentKey && currentKey !== sdkKey) {
+			if (!sdkKey) {
+				console.log(
+					`User provided ${provider} api key set. Use the Agentuity AI Gateway more features.`
+				);
+			}
+			return originalFn.apply(this, args);
+		}
+
+		// Route through gateway
+		const transportUrl = process.env.AGENTUITY_TRANSPORT_URL;
+		if (transportUrl && sdkKey) {
+			const opts = { ...(args[0] ?? {}) };
+			if (!opts.baseURL) {
+				opts.apiKey = sdkKey;
+				opts.baseURL = `${transportUrl}/gateway/${provider}`;
+				args[0] = opts;
+			}
+		} else if (!currentKey) {
+			warnMissingKey(envKey);
+		}
+
+		return originalFn.apply(this, args);
+	};
+}
+
+/** AI SDK core functions to wrap with telemetry injection */
+const AI_CORE_FUNCTIONS = [
+	'generateText',
+	'streamText',
+	'generateObject',
+	'streamObject',
+	'embed',
+	'embedMany',
+] as const;
+
+/** AI SDK provider packages and their factory functions */
+const AI_PROVIDER_CONFIGS = [
+	{
+		module: '@ai-sdk/openai',
+		factory: 'createOpenAI',
+		envKey: 'OPENAI_API_KEY',
+		provider: 'openai',
+	},
+	{
+		module: '@ai-sdk/anthropic',
+		factory: 'createAnthropic',
+		envKey: 'ANTHROPIC_API_KEY',
+		provider: 'anthropic',
+	},
+	{
+		module: '@ai-sdk/cohere',
+		factory: 'createCohere',
+		envKey: 'COHERE_API_KEY',
+		provider: 'cohere',
+	},
+	{
+		module: '@ai-sdk/deepseek',
+		factory: 'createDeepSeek',
+		envKey: 'DEEPSEEK_API_KEY',
+		provider: 'deepseek',
+	},
+	{
+		module: '@ai-sdk/google',
+		factory: 'createGoogleGenerativeAI',
+		envKey: 'GOOGLE_GENERATIVE_AI_API_KEY',
+		provider: 'google-ai-studio',
+	},
+	{ module: '@ai-sdk/xai', factory: 'createXai', envKey: 'XAI_API_KEY', provider: 'grok' },
+	{ module: '@ai-sdk/groq', factory: 'createGroq', envKey: 'GROQ_API_KEY', provider: 'groq' },
+	{
+		module: '@ai-sdk/mistral',
+		factory: 'createMistral',
+		envKey: 'MISTRAL_API_KEY',
+		provider: 'mistral',
+	},
+	{
+		module: '@ai-sdk/perplexity',
+		factory: 'createPerplexity',
+		envKey: 'PERPLEXITY_API_KEY',
+		provider: 'perplexity-ai',
+	},
+] as const;
+
+/**
+ * Patch AI SDK core functions (generateText, streamText, etc.) with telemetry injection.
+ */
+export async function applyAISDKCorePatches(): Promise<void> {
+	try {
+		const aiModule = await import('ai');
+
+		for (const fnName of AI_CORE_FUNCTIONS) {
+			const original = (aiModule as any)[fnName];
+			if (typeof original === 'function') {
+				(aiModule as any)[fnName] = wrapWithTelemetry(original);
+			}
+		}
+	} catch {
+		// 'ai' package not installed — skip
+	}
+}
+
+/**
+ * Patch AI SDK provider factory functions to route through the AI Gateway.
+ */
+export async function applyAISDKProviderPatches(): Promise<void> {
+	for (const config of AI_PROVIDER_CONFIGS) {
+		try {
+			const mod = await import(config.module);
+			const original = mod[config.factory];
+			if (typeof original === 'function') {
+				mod[config.factory] = wrapProviderFactory(original, config.envKey, config.provider);
+			}
+		} catch {
+			// Provider package not installed — skip
+		}
+	}
+}

package/src/dev-patches/gateway.ts

@@ -0,0 +1,70 @@
+/**
+ * Runtime LLM Gateway patches for dev mode.
+ *
+ * Replaces the build-time patches from cli/src/cmd/build/patch/llm.ts.
+ * Sets environment variables to route LLM SDK calls through the Agentuity AI Gateway
+ * when the user hasn't provided their own API keys.
+ */
+
+interface GatewayConfig {
+	apiKeyEnv: string;
+	baseUrlEnv: string;
+	provider: string;
+}
+
+const GATEWAY_CONFIGS: GatewayConfig[] = [
+	{ apiKeyEnv: 'ANTHROPIC_API_KEY', baseUrlEnv: 'ANTHROPIC_BASE_URL', provider: 'anthropic' },
+	{ apiKeyEnv: 'GROQ_API_KEY', baseUrlEnv: 'GROQ_BASE_URL', provider: 'groq' },
+	{ apiKeyEnv: 'OPENAI_API_KEY', baseUrlEnv: 'OPENAI_BASE_URL', provider: 'openai' },
+];
+
+function warnMissingKey(envKey: string): void {
+	const isDev =
+		process.env.AGENTUITY_ENVIRONMENT === 'development' || process.env.NODE_ENV !== 'production';
+	if (isDev) {
+		console.error('[ERROR] No credentials found for this AI provider. To fix this, either:');
+		console.error(
+			'  1. Login to Agentuity Cloud (agentuity auth login) to use the AI Gateway (recommended)'
+		);
+		console.error(`  2. Set ${envKey} in your .env file to use the provider directly`);
+	} else {
+		console.error(`[ERROR] The environment variable ${envKey} is required. Either:`);
+		console.error(
+			'  1. Use Agentuity Cloud AI Gateway by ensuring AGENTUITY_SDK_KEY is configured'
+		);
+		console.error(`  2. Set ${envKey} using "agentuity env set ${envKey}" and redeploy`);
+	}
+}
+
+/**
+ * Set environment variables to route LLM calls through the AI Gateway.
+ *
+ * For each provider, if the user hasn't set their own API key (or it equals
+ * the SDK key), we redirect to the gateway. This matches the behavior of
+ * the build-time patches in patch/llm.ts.
+ */
+export function applyGatewayPatches(): void {
+	const sdkKey = process.env.AGENTUITY_SDK_KEY;
+	const gatewayUrl =
+		process.env.AGENTUITY_AIGATEWAY_URL ||
+		process.env.AGENTUITY_TRANSPORT_URL ||
+		(sdkKey ? 'https://agentuity.ai' : '');
+
+	for (const config of GATEWAY_CONFIGS) {
+		const currentKey = process.env[config.apiKeyEnv];
+
+		// If the user provided their own key (and it's not the SDK key), leave it alone
+		if (currentKey && currentKey !== sdkKey) {
+			continue;
+		}
+
+		// Route through gateway if we have both URL and SDK key
+		if (gatewayUrl && sdkKey) {
+			process.env[config.apiKeyEnv] = sdkKey;
+			process.env[config.baseUrlEnv] = `${gatewayUrl}/gateway/${config.provider}`;
+			console.debug(`Enabled Agentuity AI Gateway for ${config.provider}`);
+		} else if (!currentKey) {
+			warnMissingKey(config.apiKeyEnv);
+		}
+	}
+}

package/src/dev-patches/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Runtime dev patches — replaces build-time Bun.build patches for dev mode.
+ *
+ * When --experimental-no-bundle is used, the generated entry file (src/generated/app.ts)
+ * is run directly by Bun without bundling. These runtime patches apply the same
+ * monkey-patches that would normally be injected by the Bun.build plugin during bundling.
+ *
+ * Three categories of patches:
+ * 1. Gateway: Set env vars to route LLM calls through Agentuity AI Gateway
+ * 2. AI SDK: Wrap Vercel AI SDK functions with telemetry + gateway config
+ * 3. OTel LLM: Wrap LLM SDK .create() methods with OpenTelemetry spans
+ */
+
+import { applyGatewayPatches } from './gateway';
+import { applyAISDKCorePatches, applyAISDKProviderPatches } from './aisdk';
+import { applyOtelLLMPatches } from './otel-llm';
+
+/**
+ * Apply all runtime dev patches.
+ *
+ * Must be called:
+ * - AFTER bootstrapRuntimeEnv() (so env vars like AGENTUITY_SDK_KEY are loaded)
+ * - BEFORE any user code imports LLM SDKs
+ */
+export async function applyDevPatches(): Promise<void> {
+	// 1. Set gateway env vars first (other patches may read them)
+	applyGatewayPatches();
+
+	// 2. Patch AI SDK core functions (telemetry injection)
+	await applyAISDKCorePatches();
+
+	// 3. Patch AI SDK provider factories (gateway routing)
+	await applyAISDKProviderPatches();
+
+	// 4. Patch LLM SDK prototypes with OTel spans
+	await applyOtelLLMPatches();
+}

package/src/dev-patches/otel-llm.ts

@@ -0,0 +1,408 @@
+/**
+ * Runtime OpenTelemetry LLM instrumentation patches for dev mode.
+ *
+ * Replaces the build-time patches from cli/src/cmd/build/patch/otel-llm.ts.
+ * Wraps LLM SDK methods (OpenAI, Anthropic, Groq) with OTel spans to capture
+ * model, tokens, latency, and streaming support.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { SpanKind, SpanStatusCode, trace } from '@opentelemetry/api';
+import type { Span } from '@opentelemetry/api';
+
+const ATTR_GEN_AI_SYSTEM = 'gen_ai.system';
+const ATTR_GEN_AI_REQUEST_MODEL = 'gen_ai.request.model';
+const ATTR_GEN_AI_REQUEST_MAX_TOKENS = 'gen_ai.request.max_tokens';
+const ATTR_GEN_AI_REQUEST_TEMPERATURE = 'gen_ai.request.temperature';
+const ATTR_GEN_AI_REQUEST_TOP_P = 'gen_ai.request.top_p';
+const ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY = 'gen_ai.request.frequency_penalty';
+const ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY = 'gen_ai.request.presence_penalty';
+const ATTR_GEN_AI_RESPONSE_MODEL = 'gen_ai.response.model';
+const ATTR_GEN_AI_RESPONSE_ID = 'gen_ai.response.id';
+const ATTR_GEN_AI_RESPONSE_FINISH_REASONS = 'gen_ai.response.finish_reasons';
+const ATTR_GEN_AI_USAGE_INPUT_TOKENS = 'gen_ai.usage.input_tokens';
+const ATTR_GEN_AI_USAGE_OUTPUT_TOKENS = 'gen_ai.usage.output_tokens';
+const ATTR_GEN_AI_OPERATION_NAME = 'gen_ai.operation.name';
+const ATTR_GEN_AI_REQUEST_MESSAGES = 'gen_ai.request.messages';
+const ATTR_GEN_AI_RESPONSE_TEXT = 'gen_ai.response.text';
+
+const otelTracer = trace.getTracer('@agentuity/otel-llm', '1.0.0');
+
+interface OtelPatchConfig {
+	provider: string;
+	inputTokensField: string;
+	outputTokensField: string;
+	responseIdField: string;
+	finishReasonExtractor: (response: any) => string | undefined;
+	responseContentExtractor: (response: any) => string | undefined;
+	requestMessagesField: string;
+	streamDeltaContentExtractor: (chunk: any) => string | undefined;
+	streamFinishReasonExtractor: (chunk: any) => string | undefined;
+	streamUsageExtractor: (chunk: any) => any;
+}
+
+function wrapAsyncIterator(
+	iterator: AsyncIterator<any>,
+	span: Span,
+	config: OtelPatchConfig
+): AsyncIterableIterator<any> {
+	const contentChunks: string[] = [];
+	let finishReason: string | null = null;
+	let usage: any = null;
+	let model: string | null = null;
+	let responseId: string | null = null;
+
+	return {
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+		async next() {
+			try {
+				const result = await iterator.next();
+				if (result.done) {
+					// Stream complete — finalize span
+					if (contentChunks.length > 0) {
+						span.setAttribute(ATTR_GEN_AI_RESPONSE_TEXT, contentChunks.join(''));
+					}
+					if (finishReason) {
+						span.setAttribute(
+							ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
+							JSON.stringify([finishReason])
+						);
+					}
+					if (model) {
+						span.setAttribute(ATTR_GEN_AI_RESPONSE_MODEL, model);
+					}
+					if (responseId) {
+						span.setAttribute(ATTR_GEN_AI_RESPONSE_ID, responseId);
+					}
+					if (usage) {
+						if (usage[config.inputTokensField] !== undefined) {
+							span.setAttribute(
+								ATTR_GEN_AI_USAGE_INPUT_TOKENS,
+								usage[config.inputTokensField]
+							);
+						}
+						if (usage[config.outputTokensField] !== undefined) {
+							span.setAttribute(
+								ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
+								usage[config.outputTokensField]
+							);
+						}
+					}
+					span.setStatus({ code: SpanStatusCode.OK });
+					span.end();
+					return result;
+				}
+
+				const chunk = result.value;
+
+				if (chunk.model && !model) model = chunk.model;
+				if (chunk.id && !responseId) responseId = chunk.id;
+
+				const deltaContent = config.streamDeltaContentExtractor(chunk);
+				if (deltaContent) contentChunks.push(deltaContent);
+
+				const chunkFinishReason = config.streamFinishReasonExtractor(chunk);
+				if (chunkFinishReason) finishReason = chunkFinishReason;
+
+				const chunkUsage = config.streamUsageExtractor(chunk);
+				if (chunkUsage) usage = chunkUsage;
+
+				return result;
+			} catch (error: any) {
+				span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+				span.recordException(error);
+				span.end();
+				throw error;
+			}
+		},
+		async return(value?: any) {
+			span.setStatus({ code: SpanStatusCode.OK });
+			span.end();
+			if (iterator.return) {
+				return iterator.return(value);
+			}
+			return { done: true as const, value };
+		},
+		async throw(error?: any) {
+			span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+			span.recordException(error);
+			span.end();
+			if (iterator.throw) {
+				return iterator.throw(error);
+			}
+			throw error;
+		},
+	};
+}
+
+function wrapStream(stream: any, span: Span, config: OtelPatchConfig): any {
+	const originalIterator = stream[Symbol.asyncIterator]();
+	const wrappedIterator = wrapAsyncIterator(originalIterator, span, config);
+
+	return new Proxy(stream, {
+		get(target, prop) {
+			if (prop === Symbol.asyncIterator) {
+				return () => wrappedIterator;
+			}
+			const value = target[prop];
+			if (typeof value === 'function') {
+				return value.bind(target);
+			}
+			return value;
+		},
+	});
+}
+
+function createOtelWrapper(
+	originalCreate: (...args: any[]) => any,
+	config: OtelPatchConfig
+): (body: any, options?: any) => any {
+	return function _agentuityOtelCreate(this: any, body: any, options?: any) {
+		const attributes: Record<string, any> = {
+			[ATTR_GEN_AI_SYSTEM]: config.provider,
+			[ATTR_GEN_AI_OPERATION_NAME]: 'chat',
+		};
+
+		if (body.model) attributes[ATTR_GEN_AI_REQUEST_MODEL] = body.model;
+		if (body.max_tokens) attributes[ATTR_GEN_AI_REQUEST_MAX_TOKENS] = body.max_tokens;
+		if (body.temperature !== undefined)
+			attributes[ATTR_GEN_AI_REQUEST_TEMPERATURE] = body.temperature;
+		if (body.top_p !== undefined) attributes[ATTR_GEN_AI_REQUEST_TOP_P] = body.top_p;
+		if (body.frequency_penalty !== undefined)
+			attributes[ATTR_GEN_AI_REQUEST_FREQUENCY_PENALTY] = body.frequency_penalty;
+		if (body.presence_penalty !== undefined)
+			attributes[ATTR_GEN_AI_REQUEST_PRESENCE_PENALTY] = body.presence_penalty;
+
+		// Capture request messages
+		const messages = body[config.requestMessagesField];
+		if (messages && Array.isArray(messages)) {
+			try {
+				attributes[ATTR_GEN_AI_REQUEST_MESSAGES] = JSON.stringify(messages);
+			} catch {
+				// Ignore serialization errors
+			}
+		}
+
+		const spanName = body.model ? `chat ${body.model}` : 'chat';
+
+		return otelTracer.startActiveSpan(
+			spanName,
+			{ attributes, kind: SpanKind.CLIENT },
+			(span: Span) => {
+				let result: any;
+				try {
+					result = originalCreate.call(this, body, options);
+				} catch (error: any) {
+					span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+					span.recordException(error);
+					span.end();
+					throw error;
+				}
+
+				// Handle streaming responses
+				if (body.stream) {
+					if (result && typeof result.then === 'function') {
+						return result
+							.then((stream: any) => {
+								try {
+									return wrapStream(stream, span, config);
+								} catch (error: any) {
+									span.setStatus({
+										code: SpanStatusCode.ERROR,
+										message: error?.message,
+									});
+									span.recordException(error);
+									span.end();
+									throw error;
+								}
+							})
+							.catch((error: any) => {
+								span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+								span.recordException(error);
+								span.end();
+								throw error;
+							});
+					}
+					try {
+						return wrapStream(result, span, config);
+					} catch (error: any) {
+						span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+						span.recordException(error);
+						span.end();
+						throw error;
+					}
+				}
+
+				// Handle non-streaming responses
+				if (result && typeof result.then === 'function') {
+					return result
+						.then((response: any) => {
+							if (response) {
+								if (response.model) {
+									span.setAttribute(ATTR_GEN_AI_RESPONSE_MODEL, response.model);
+								}
+								if (response[config.responseIdField]) {
+									span.setAttribute(
+										ATTR_GEN_AI_RESPONSE_ID,
+										response[config.responseIdField]
+									);
+								}
+								if (response.usage) {
+									if (response.usage[config.inputTokensField] !== undefined) {
+										span.setAttribute(
+											ATTR_GEN_AI_USAGE_INPUT_TOKENS,
+											response.usage[config.inputTokensField]
+										);
+									}
+									if (response.usage[config.outputTokensField] !== undefined) {
+										span.setAttribute(
+											ATTR_GEN_AI_USAGE_OUTPUT_TOKENS,
+											response.usage[config.outputTokensField]
+										);
+									}
+								}
+								const finishReason = config.finishReasonExtractor(response);
+								if (finishReason) {
+									span.setAttribute(
+										ATTR_GEN_AI_RESPONSE_FINISH_REASONS,
+										JSON.stringify([finishReason])
+									);
+								}
+								const responseContent = config.responseContentExtractor(response);
+								if (responseContent) {
+									span.setAttribute(ATTR_GEN_AI_RESPONSE_TEXT, responseContent);
+								}
+							}
+							span.setStatus({ code: SpanStatusCode.OK });
+							span.end();
+							return response;
+						})
+						.catch((error: any) => {
+							span.setStatus({ code: SpanStatusCode.ERROR, message: error?.message });
+							span.recordException(error);
+							span.end();
+							throw error;
+						});
+				}
+
+				span.end();
+				return result;
+			}
+		);
+	};
+}
+
+/** Provider-specific configurations matching the build-time patches */
+const OTEL_CONFIGS: Array<{
+	module: string;
+	className: string;
+	config: OtelPatchConfig;
+}> = [
+	{
+		module: 'openai',
+		// In the openai SDK, the Completions class is in resources/chat/completions
+		// We need to import the main module and access the prototype
+		className: 'Completions',
+		config: {
+			provider: 'openai',
+			inputTokensField: 'prompt_tokens',
+			outputTokensField: 'completion_tokens',
+			responseIdField: 'id',
+			finishReasonExtractor: (r) => r?.choices?.[0]?.finish_reason,
+			responseContentExtractor: (r) => r?.choices?.[0]?.message?.content,
+			requestMessagesField: 'messages',
+			streamDeltaContentExtractor: (c) => c?.choices?.[0]?.delta?.content,
+			streamFinishReasonExtractor: (c) => c?.choices?.[0]?.finish_reason,
+			streamUsageExtractor: (c) => c?.usage,
+		},
+	},
+	{
+		module: '@anthropic-ai/sdk',
+		className: 'Messages',
+		config: {
+			provider: 'anthropic',
+			inputTokensField: 'input_tokens',
+			outputTokensField: 'output_tokens',
+			responseIdField: 'id',
+			finishReasonExtractor: (r) => r?.stop_reason,
+			responseContentExtractor: (r) => r?.content?.[0]?.text,
+			requestMessagesField: 'messages',
+			streamDeltaContentExtractor: (c) => c?.delta?.text,
+			streamFinishReasonExtractor: (c) => c?.delta?.stop_reason,
+			streamUsageExtractor: (c) => c?.usage,
+		},
+	},
+	{
+		module: 'groq-sdk',
+		className: 'Completions',
+		config: {
+			provider: 'groq',
+			inputTokensField: 'prompt_tokens',
+			outputTokensField: 'completion_tokens',
+			responseIdField: 'id',
+			finishReasonExtractor: (r) => r?.choices?.[0]?.finish_reason,
+			responseContentExtractor: (r) => r?.choices?.[0]?.message?.content,
+			requestMessagesField: 'messages',
+			streamDeltaContentExtractor: (c) => c?.choices?.[0]?.delta?.content,
+			streamFinishReasonExtractor: (c) => c?.choices?.[0]?.finish_reason,
+			streamUsageExtractor: (c) => c?.x_groq?.usage,
+		},
+	},
+];
+
+/**
+ * Find a class prototype by name within a module's exports (recursive search).
+ * The SDKs nest classes in sub-objects (e.g., openai.Chat.Completions).
+ */
+function findPrototype(obj: any, className: string, depth = 0): any | null {
+	if (depth > 5 || !obj || typeof obj !== 'object') return null;
+
+	// Check if this object itself is the class we're looking for
+	if (typeof obj === 'function' && obj.name === className && obj.prototype?.create) {
+		return obj.prototype;
+	}
+
+	// Search properties
+	for (const key of Object.keys(obj)) {
+		try {
+			const val = obj[key];
+			if (typeof val === 'function' && val.name === className && val.prototype?.create) {
+				return val.prototype;
+			}
+			if (typeof val === 'object' && val !== null) {
+				const found = findPrototype(val, className, depth + 1);
+				if (found) return found;
+			}
+		} catch {
+			// Skip inaccessible properties
+		}
+	}
+	return null;
+}
+
+/**
+ * Apply OTel instrumentation patches to LLM SDK prototype methods.
+ */
+export async function applyOtelLLMPatches(): Promise<void> {
+	for (const { module: moduleName, className, config } of OTEL_CONFIGS) {
+		try {
+			const mod = await import(moduleName);
+			const proto = findPrototype(mod, className);
+
+			if (!proto || typeof proto.create !== 'function') {
+				console.debug(
+					`[Agentuity OTel] Skipping patch: ${className}.prototype.create not found in ${moduleName}`
+				);
+				continue;
+			}
+
+			const originalCreate = proto.create;
+			proto.create = createOtelWrapper(originalCreate, config);
+		} catch {
+			// Module not installed — skip
+		}
+	}
+}

package/src/index.ts

@@ -263,3 +263,6 @@ export { bootstrapRuntimeEnv, type RuntimeBootstrapOptions, mimeTypes } from '@a
 
 // bun-s3-patch.ts exports
 export { patchBunS3ForStorageDev, isAgentuityStorageEndpoint } from './bun-s3-patch';
+
+// dev-patches exports (runtime monkey-patches for --experimental-no-bundle dev mode)
+export { applyDevPatches } from './dev-patches';