@jterrazz/intelligence 5.0.0 → 7.0.0

package/dist/index.js

@@ -1,11 +1,126 @@
-import { t as parseText } from "./parse-text.js";
-import { Langfuse } from "langfuse";
-import { generateText } from "ai";
-import { jsonrepair } from "jsonrepair";
-import { z } from "zod/v4";
-import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { OpenTelemetry } from "@ai-sdk/otel";
+import { extractJsonMiddleware, registerTelemetry, wrapLanguageModel } from "ai";
+import { trace } from "@opentelemetry/api";
 import { createOpenAI } from "@ai-sdk/openai";
-//#region src/logging/logging.middleware.ts
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+//#region src/middleware/agent.middleware.ts
+const AGENT_ATTRIBUTE = "gen_ai.agent.name";
+/**
+* Creates middleware that names the AI SDK's inference span after the agent.
+*
+* The AI SDK names that span `chat <model>` and only puts the agent identity
+* (`gen_ai.agent.name`, from `experimental_telemetry.functionId`) on the
+* parent `invoke_agent` span. Langfuse extracts model, usage and cost from
+* the inference span alone, so a pipeline that forwards only that span would
+* otherwise show every agent as "chat <model>". This runs inside the
+* inference span's context (the AI SDK activates it for the provider call),
+* so the active span is the right one.
+*
+* Never throws: all enrichment is best-effort.
+*/
+function createAgentMiddleware(options) {
+	const { agentName } = options;
+	const nameActiveSpan = () => {
+		try {
+			const span = trace.getActiveSpan();
+			if (!span) return;
+			span.updateName(agentName);
+			span.setAttribute(AGENT_ATTRIBUTE, agentName);
+		} catch {}
+	};
+	return {
+		specificationVersion: "v4",
+		wrapGenerate: async ({ doGenerate }) => {
+			nameActiveSpan();
+			return doGenerate();
+		},
+		wrapStream: async ({ doStream }) => {
+			nameActiveSpan();
+			return doStream();
+		}
+	};
+}
+//#endregion
+//#region src/middleware/cost.middleware.ts
+const COST_ATTRIBUTE = "gen_ai.usage.cost";
+function resolveCost(providerMetadata, usage, pricing) {
+	const actualCost = providerMetadata?.openrouter?.usage?.cost;
+	if (typeof actualCost === "number" && actualCost > 0) return actualCost;
+	if (pricing) {
+		const inputTokens = usage?.inputTokens?.total ?? 0;
+		const outputTokens = usage?.outputTokens?.total ?? 0;
+		return inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+	}
+}
+function recordCost(cost) {
+	if (cost === void 0) return;
+	trace.getActiveSpan()?.setAttribute(COST_ATTRIBUTE, cost);
+}
+/**
+* Creates middleware that records the USD cost of a generation as
+* `gen_ai.usage.cost` on the active OpenTelemetry span — the AI SDK's own
+* inference span (`gen_ai.operation.name = chat`), which is what Langfuse
+* ingests as a generation.
+*
+* Resolution order:
+* 1. Actual cost reported by the provider (currently: OpenRouter's
+*    `providerMetadata.openrouter.usage.cost`).
+* 2. Estimated cost from `pricing` (USD per million input/output tokens),
+*    computed from the reported token usage.
+*
+* When neither is available nothing is written: `gen_ai.request.model` is
+* left to the AI SDK (the bare model id), so Langfuse can still price the
+* generation from its own model catalogue. Langfuse prioritizes
+* `gen_ai.usage.cost` over that inference when both exist.
+*
+* Never throws: all enrichment is best-effort.
+*
+* @example
+* ```ts
+* const model = wrapLanguageModel({
+*   model: provider.model('google/gemini-2.5-flash-lite'),
+*   middleware: [createCostMiddleware({ pricing: { input: 0.1, output: 0.4 } })],
+* });
+* ```
+*/
+function createCostMiddleware(options = {}) {
+	const { pricing } = options;
+	return {
+		specificationVersion: "v4",
+		wrapGenerate: async ({ doGenerate }) => {
+			const result = await doGenerate();
+			try {
+				recordCost(resolveCost(result.providerMetadata, result.usage, pricing));
+			} catch {}
+			return result;
+		},
+		wrapStream: async ({ doStream }) => {
+			const result = await doStream();
+			let finishUsage;
+			let finishProviderMetadata;
+			const transformStream = new TransformStream({
+				transform(chunk, controller) {
+					if (chunk.type === "finish") {
+						finishUsage = chunk.usage;
+						finishProviderMetadata = chunk.providerMetadata;
+					}
+					controller.enqueue(chunk);
+				},
+				flush() {
+					try {
+						recordCost(resolveCost(finishProviderMetadata, finishUsage, pricing));
+					} catch {}
+				}
+			});
+			return {
+				...result,
+				stream: result.stream.pipeThrough(transformStream)
+			};
+		}
+	};
+}
+//#endregion
+//#region src/middleware/logging.middleware.ts
 /**
 * Creates middleware that logs AI SDK requests and responses.
 */
@@ -79,522 +194,654 @@ function createLoggingMiddleware(options) {
 	};
 }
 //#endregion
-//#region src/observability/observability.middleware.ts
-/**
-* Helper to create type-safe observability metadata for providerOptions
-*/
-function withObservability(meta) {
-	return { observability: meta };
-}
-/**
-* Creates middleware that sends generation data to an observability platform.
-*/
-function createObservabilityMiddleware(options) {
-	const { observability, providerMetadata } = options;
-	return {
-		specificationVersion: "v4",
-		wrapGenerate: async ({ doGenerate, params, model }) => {
-			const startTime = /* @__PURE__ */ new Date();
-			const meta = params.providerOptions?.observability;
-			const result = await doGenerate();
-			const endTime = /* @__PURE__ */ new Date();
-			if (meta?.traceId) {
-				const extracted = providerMetadata?.extract(result.providerMetadata);
-				const outputText = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
-				observability.generation({
-					traceId: meta.traceId,
-					name: meta.name ?? "generation",
-					model: model.modelId,
-					input: params.prompt,
-					output: outputText,
-					startTime,
-					endTime,
-					usage: extracted?.usage,
-					cost: extracted?.cost,
-					metadata: meta.metadata
-				});
-			}
-			return result;
-		},
-		wrapStream: async ({ doStream, params, model }) => {
-			const startTime = /* @__PURE__ */ new Date();
-			const meta = params.providerOptions?.observability;
-			const result = await doStream();
-			if (!meta?.traceId) return result;
-			const chunks = [];
-			const transformStream = new TransformStream({
-				transform(chunk, controller) {
-					if (chunk.type === "text-delta") chunks.push(chunk.delta);
-					controller.enqueue(chunk);
-				},
-				flush() {
-					const endTime = /* @__PURE__ */ new Date();
-					observability.generation({
-						traceId: meta.traceId,
-						name: meta.name ?? "generation",
-						model: model.modelId,
-						input: params.prompt,
-						output: chunks.join(""),
-						startTime,
-						endTime,
-						metadata: meta.metadata
-					});
-				}
-			});
-			return {
-				specificationVersion: "v4",
-				...result,
-				stream: result.stream.pipeThrough(transformStream)
-			};
-		}
-	};
-}
-//#endregion
-//#region src/observability/langfuse.adapter.ts
-/**
-* Langfuse adapter implementing ObservabilityPort
-*/
-var LangfuseAdapter = class {
-	client;
-	constructor(config) {
-		this.client = new Langfuse({
-			secretKey: config.secretKey,
-			publicKey: config.publicKey,
-			baseUrl: config.baseUrl,
-			environment: config.environment,
-			release: config.release
-		});
+//#region node_modules/@ai-sdk/provider/dist/index.js
+var marker = "vercel.ai.error";
+var symbol = Symbol.for(marker);
+var _a;
+var _b;
+var AISDKError = class _AISDKError extends (_b = Error, _a = symbol, _b) {
+	/**
+	* Creates an AI SDK Error.
+	*
+	* @param {Object} params - The parameters for creating the error.
+	* @param {string} params.name - The name of the error.
+	* @param {string} params.message - The error message.
+	* @param {unknown} [params.cause] - The underlying cause of the error.
+	*/
+	constructor({ name: name15, message, cause }) {
+		super(message);
+		this[_a] = true;
+		this.name = name15;
+		this.cause = cause;
 	}
-	async flush() {
-		await this.client.flushAsync();
-	}
-	generation(params) {
-		const usageDetails = params.usage ? {
-			input: params.usage.input,
-			output: params.usage.output,
-			total: params.usage.total ?? params.usage.input + params.usage.output,
-			...params.usage.reasoning !== void 0 && { reasoning: params.usage.reasoning },
-			...params.usage.cacheRead !== void 0 && { cache_read: params.usage.cacheRead },
-			...params.usage.cacheWrite !== void 0 && { cache_write: params.usage.cacheWrite }
-		} : void 0;
-		const costDetails = params.cost ? {
-			total: params.cost.total,
-			...params.cost.input !== void 0 && { input: params.cost.input },
-			...params.cost.output !== void 0 && { output: params.cost.output }
-		} : void 0;
-		this.client.generation({
-			traceId: params.traceId,
-			name: params.name,
-			model: params.model,
-			input: params.input,
-			output: params.output,
-			startTime: params.startTime,
-			endTime: params.endTime,
-			usageDetails,
-			costDetails,
-			metadata: params.metadata
-		});
+	/**
+	* Checks if the given error is an AI SDK Error.
+	* @param {unknown} error - The error to check.
+	* @returns {boolean} True if the error is an AI SDK Error, false otherwise.
+	*/
+	static isInstance(error) {
+		return _AISDKError.hasMarker(error, marker);
 	}
-	async shutdown() {
-		await this.client.shutdownAsync();
+	static hasMarker(error, marker16) {
+		const markerSymbol = Symbol.for(marker16);
+		return error != null && typeof error === "object" && markerSymbol in error && typeof error[markerSymbol] === "boolean" && error[markerSymbol] === true;
 	}
-	trace(params) {
-		this.client.trace({
-			id: params.id,
-			name: params.name,
-			metadata: params.metadata
+};
+var name = "AI_APICallError";
+var marker2 = `vercel.ai.error.${name}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var _b2;
+var APICallError = class extends (_b2 = AISDKError, _a2 = symbol2, _b2) {
+	constructor({ message, url, requestBodyValues, statusCode, responseHeaders, responseBody, cause, isRetryable = statusCode != null && (statusCode === 408 || statusCode === 409 || statusCode === 429 || statusCode >= 500), data }) {
+		super({
+			name,
+			message,
+			cause
 		});
+		this[_a2] = true;
+		this.url = url;
+		this.requestBodyValues = requestBodyValues;
+		this.statusCode = statusCode;
+		this.responseHeaders = responseHeaders;
+		this.responseBody = responseBody;
+		this.isRetryable = isRetryable;
+		this.data = data;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker2);
 	}
 };
-//#endregion
-//#region src/observability/noop.adapter.ts
-/**
-* No-op adapter that silently discards all observability data.
-* Useful for testing, development, or when observability is disabled.
-*/
-var NoopObservabilityAdapter = class {
-	async flush() {}
-	generation(_params) {}
-	async shutdown() {}
-	trace(_params) {}
-};
-//#endregion
-//#region src/result/result.ts
-/**
-* Create a successful result
-*/
-function generationSuccess(data) {
-	return {
-		success: true,
-		data
-	};
+var name2 = "AI_EmptyResponseBodyError";
+var marker3 = `vercel.ai.error.${name2}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+var _b3;
+(class extends (_b3 = AISDKError, _a3 = symbol3, _b3) {
+	constructor({ message = "Empty response body" } = {}) {
+		super({
+			name: name2,
+			message
+		});
+		this[_a3] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker3);
+	}
+});
+function getErrorMessage(error) {
+	if (error == null) return "unknown error";
+	if (typeof error === "string") return error;
+	if (error instanceof Error) return error.toString();
+	return JSON.stringify(error);
 }
-/**
-* Create a failed result
-*/
-function generationFailure(code, message, cause) {
-	return {
-		success: false,
-		error: {
-			code,
+var name3 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name3}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var _b4;
+(class extends (_b4 = AISDKError, _a4 = symbol4, _b4) {
+	constructor({ message, cause, argument }) {
+		super({
+			name: name3,
 			message,
 			cause
-		}
-	};
-}
-/**
-* Classify an error into a GenerationErrorCode
-*/
-function classifyError(error) {
-	if (error instanceof Error) {
-		const message = error.message.toLowerCase();
-		if (message.includes("timeout") || message.includes("timed out")) return "TIMEOUT";
-		if (message.includes("rate limit") || message.includes("429")) return "RATE_LIMITED";
-		if (message.includes("parse") || message.includes("json") || message.includes("unexpected token")) return "PARSING_FAILED";
-		if (message.includes("valid") || message.includes("schema") || message.includes("zod")) return "VALIDATION_FAILED";
-	}
-	return "AI_GENERATION_FAILED";
-}
-/**
-* Check if a result is successful (type guard)
-*/
-function isSuccess(result) {
-	return result.success;
-}
-/**
-* Check if a result is a failure (type guard)
-*/
-function isFailure(result) {
-	return !result.success;
-}
-/**
-* Unwrap a result, throwing if it fails
-*/
-function unwrap(result) {
-	if (result.success) return result.data;
-	throw new Error(`${result.error.code}: ${result.error.message}`);
-}
-/**
-* Unwrap a result with a default value for failures
-*/
-function unwrapOr(result, defaultValue) {
-	return result.success ? result.data : defaultValue;
-}
-//#endregion
-//#region src/parsing/parse-object.ts
-const MARKDOWN_CODE_BLOCK_RE = /```(?:json)?\r?\n([^`]*?)\r?\n```/g;
-/**
-* Error thrown when object parsing fails.
-* Contains the original text for debugging purposes.
-*/
-var ParseObjectError = class extends Error {
-	name = "ParseObjectError";
-	cause;
-	text;
-	constructor(message, cause, text) {
-		super(message);
-		this.cause = cause;
+		});
+		this[_a4] = true;
+		this.argument = argument;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker4);
+	}
+});
+var name4 = "AI_InvalidPromptError";
+var marker5 = `vercel.ai.error.${name4}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var _b5;
+(class extends (_b5 = AISDKError, _a5 = symbol5, _b5) {
+	constructor({ prompt, message, cause }) {
+		super({
+			name: name4,
+			message: `Invalid prompt: ${message}`,
+			cause
+		});
+		this[_a5] = true;
+		this.prompt = prompt;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker5);
+	}
+});
+var name5 = "AI_InvalidResponseDataError";
+var marker6 = `vercel.ai.error.${name5}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var _b6;
+(class extends (_b6 = AISDKError, _a6 = symbol6, _b6) {
+	constructor({ data, message = `Invalid response data: ${JSON.stringify(data)}.` }) {
+		super({
+			name: name5,
+			message
+		});
+		this[_a6] = true;
+		this.data = data;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker6);
+	}
+});
+var name6 = "AI_JSONParseError";
+var marker7 = `vercel.ai.error.${name6}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var _b7;
+(class extends (_b7 = AISDKError, _a7 = symbol7, _b7) {
+	constructor({ text, cause }) {
+		super({
+			name: name6,
+			message: `JSON parsing failed: Text: ${text}.
+Error message: ${getErrorMessage(cause)}`,
+			cause
+		});
+		this[_a7] = true;
 		this.text = text;
 	}
-};
-function convertToPrimitive(value, schema) {
-	if (schema instanceof z.ZodBoolean) return Boolean(value);
-	if (schema instanceof z.ZodNull) return null;
-	if (schema instanceof z.ZodNumber) return Number(value);
-	if (schema instanceof z.ZodString) return String(value);
-	return value;
-}
-function extractArray(text, originalText) {
-	const start = text.indexOf("[");
-	const end = text.lastIndexOf("]");
-	if (start === -1 || end === -1) throw new ParseObjectError("No array found in response", void 0, originalText);
-	try {
-		const raw = text.slice(start, end + 1);
-		return JSON.parse(jsonrepair(raw));
-	} catch (error) {
-		throw new ParseObjectError("Failed to parse array JSON", error, originalText);
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker7);
 	}
-}
-function extractObject(text, originalText) {
-	const start = text.indexOf("{");
-	const end = text.lastIndexOf("}");
-	if (start === -1 || end === -1) throw new ParseObjectError("No object found in response", void 0, originalText);
-	try {
-		const raw = text.slice(start, end + 1);
-		return JSON.parse(jsonrepair(raw));
-	} catch (error) {
-		throw new ParseObjectError("Failed to parse object JSON", error, originalText);
+});
+var name7 = "AI_LoadAPIKeyError";
+var marker8 = `vercel.ai.error.${name7}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+var _b8;
+(class extends (_b8 = AISDKError, _a8 = symbol8, _b8) {
+	constructor({ message }) {
+		super({
+			name: name7,
+			message
+		});
+		this[_a8] = true;
 	}
-}
-function extractPrimitive(text, schema) {
-	const trimmed = text.trim();
-	try {
-		return convertToPrimitive(JSON.parse(trimmed), schema);
-	} catch {
-		return convertToPrimitive(trimmed, schema);
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker8);
 	}
-}
-function extractBySchemaType(text, schema, originalText) {
-	if (schema instanceof z.ZodArray) return extractArray(text, originalText);
-	if (schema instanceof z.ZodObject) return extractObject(text, originalText);
-	if (schema instanceof z.ZodBoolean || schema instanceof z.ZodNull || schema instanceof z.ZodNumber || schema instanceof z.ZodString) return extractPrimitive(text, schema);
-	if (schema instanceof z.ZodUnion || schema instanceof z.ZodDiscriminatedUnion) {
-		if (text.indexOf("{") !== -1) return extractObject(text, originalText);
-		if (text.indexOf("[") !== -1) return extractArray(text, originalText);
-		throw new ParseObjectError("No object or array found for union type", void 0, originalText);
-	}
-	if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable) return extractBySchemaType(text, schema.unwrap(), originalText);
-	if (schema instanceof z.ZodDefault) return extractBySchemaType(text, schema.def.innerType, originalText);
-	if (schema instanceof z.ZodPipe) return extractBySchemaType(text, schema.def.in, originalText);
-	throw new ParseObjectError("Unsupported schema type", void 0, originalText);
-}
-function extractJsonFromCodeBlock(block) {
-	const content = block.replace(/```(?:json)?\r?\n([^`]*?)\r?\n```/, "$1").trim();
-	try {
-		JSON.parse(content);
-		return content;
-	} catch {
-		return null;
+});
+var name8 = "AI_LoadSettingError";
+var marker9 = `vercel.ai.error.${name8}`;
+var symbol9 = Symbol.for(marker9);
+var _a9;
+var _b9;
+(class extends (_b9 = AISDKError, _a9 = symbol9, _b9) {
+	constructor({ message }) {
+		super({
+			name: name8,
+			message
+		});
+		this[_a9] = true;
 	}
-}
-function findLongestString(strings) {
-	return strings.reduce((longest, current) => current.length > longest.length ? current : longest);
-}
-function findJsonStructures(text) {
-	const matches = [];
-	let depth = 0;
-	let start = -1;
-	for (let i = 0; i < text.length; i++) {
-		const char = text[i];
-		if (char === "{" || char === "[") {
-			if (depth === 0) start = i;
-			depth++;
-		} else if (char === "}" || char === "]") {
-			depth--;
-			if (depth === 0 && start !== -1) {
-				const candidate = text.slice(start, i + 1);
-				try {
-					JSON.parse(candidate);
-					matches.push(candidate);
-				} catch {}
-			}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker9);
+	}
+});
+var name9 = "AI_NoContentGeneratedError";
+var marker10 = `vercel.ai.error.${name9}`;
+var symbol10 = Symbol.for(marker10);
+var _a10;
+var _b10;
+(class extends (_b10 = AISDKError, _a10 = symbol10, _b10) {
+	constructor({ message = "No content generated." } = {}) {
+		super({
+			name: name9,
+			message
+		});
+		this[_a10] = true;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker10);
+	}
+});
+var name10 = "AI_NoSuchModelError";
+var marker11 = `vercel.ai.error.${name10}`;
+var symbol11 = Symbol.for(marker11);
+var _a11;
+var _b11;
+(class extends (_b11 = AISDKError, _a11 = symbol11, _b11) {
+	constructor({ errorName = name10, modelId, modelType, message = `No such ${modelType}: ${modelId}` }) {
+		super({
+			name: errorName,
+			message
+		});
+		this[_a11] = true;
+		this.modelId = modelId;
+		this.modelType = modelType;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker11);
+	}
+});
+var name11 = "AI_NoSuchProviderReferenceError";
+var marker12 = `vercel.ai.error.${name11}`;
+var symbol12 = Symbol.for(marker12);
+var _a12;
+var _b12;
+(class extends (_b12 = AISDKError, _a12 = symbol12, _b12) {
+	constructor({ provider, reference, message = `No provider reference found for provider '${provider}'. Available providers: ${Object.keys(reference).join(", ")}` }) {
+		super({
+			name: name11,
+			message
+		});
+		this[_a12] = true;
+		this.provider = provider;
+		this.reference = reference;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker12);
+	}
+});
+var name12 = "AI_TooManyEmbeddingValuesForCallError";
+var marker13 = `vercel.ai.error.${name12}`;
+var symbol13 = Symbol.for(marker13);
+var _a13;
+var _b13;
+(class extends (_b13 = AISDKError, _a13 = symbol13, _b13) {
+	constructor(options) {
+		super({
+			name: name12,
+			message: `Too many values for a single embedding call. The ${options.provider} model "${options.modelId}" can only embed up to ${options.maxEmbeddingsPerCall} values per call, but ${options.values.length} values were provided.`
+		});
+		this[_a13] = true;
+		this.provider = options.provider;
+		this.modelId = options.modelId;
+		this.maxEmbeddingsPerCall = options.maxEmbeddingsPerCall;
+		this.values = options.values;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker13);
+	}
+});
+var name13 = "AI_TypeValidationError";
+var marker14 = `vercel.ai.error.${name13}`;
+var symbol14 = Symbol.for(marker14);
+var _a14;
+var _b14;
+(class _TypeValidationError extends (_b14 = AISDKError, _a14 = symbol14, _b14) {
+	constructor({ value, cause, context }) {
+		let contextPrefix = "Type validation failed";
+		if (context == null ? void 0 : context.field) contextPrefix += ` for ${context.field}`;
+		if ((context == null ? void 0 : context.entityName) || (context == null ? void 0 : context.entityId)) {
+			contextPrefix += " (";
+			const parts = [];
+			if (context.entityName) parts.push(context.entityName);
+			if (context.entityId) parts.push(`id: "${context.entityId}"`);
+			contextPrefix += parts.join(", ");
+			contextPrefix += ")";
 		}
+		super({
+			name: name13,
+			message: `${contextPrefix}: Value: ${JSON.stringify(value)}.
+Error message: ${getErrorMessage(cause)}`,
+			cause
+		});
+		this[_a14] = true;
+		this.value = value;
+		this.context = context;
 	}
-	return matches;
-}
-function extractJsonString(text) {
-	const codeBlocks = text.match(MARKDOWN_CODE_BLOCK_RE);
-	if (codeBlocks && codeBlocks.length > 0) {
-		const validBlocks = codeBlocks.map((block) => extractJsonFromCodeBlock(block)).filter((block) => block !== null);
-		if (validBlocks.length > 0) return findLongestString(validBlocks);
-	}
-	const structures = findJsonStructures(text);
-	if (structures.length > 0) return findLongestString(structures);
-	return text.replace(/\s+/g, " ").trim();
-}
-function unescapeString(text) {
-	return text.replace(/\\"/g, "\"").replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\\\/g, "\\").replace(/\\u([0-9a-fA-F]{4})/g, (_, code) => String.fromCharCode(Number.parseInt(code, 16)));
-}
-function unescapeJsonValues(json) {
-	if (typeof json === "string") return unescapeString(json);
-	if (Array.isArray(json)) return json.map(unescapeJsonValues);
-	if (typeof json === "object" && json !== null) return Object.fromEntries(Object.entries(json).map(([key, value]) => [key, unescapeJsonValues(value)]));
-	return json;
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker14);
+	}
+	/**
+	* Wraps an error into a TypeValidationError.
+	* If the cause is already a TypeValidationError with the same value and context, it returns the cause.
+	* Otherwise, it creates a new TypeValidationError.
+	*
+	* @param {Object} params - The parameters for wrapping the error.
+	* @param {unknown} params.value - The value that failed validation.
+	* @param {unknown} params.cause - The original error or cause of the validation failure.
+	* @param {TypeValidationContext} params.context - Optional context about what is being validated.
+	* @returns {TypeValidationError} A TypeValidationError instance.
+	*/
+	static wrap({ value, cause, context }) {
+		var _a16, _b16, _c;
+		if (_TypeValidationError.isInstance(cause) && cause.value === value && ((_a16 = cause.context) == null ? void 0 : _a16.field) === (context == null ? void 0 : context.field) && ((_b16 = cause.context) == null ? void 0 : _b16.entityName) === (context == null ? void 0 : context.entityName) && ((_c = cause.context) == null ? void 0 : _c.entityId) === (context == null ? void 0 : context.entityId)) return cause;
+		return new _TypeValidationError({
+			value,
+			cause,
+			context
+		});
+	}
+});
+var name14 = "AI_UnsupportedFunctionalityError";
+var marker15 = `vercel.ai.error.${name14}`;
+var symbol15 = Symbol.for(marker15);
+var _a15;
+var _b15;
+(class extends (_b15 = AISDKError, _a15 = symbol15, _b15) {
+	constructor({ functionality, message = `'${functionality}' functionality not supported.` }) {
+		super({
+			name: name14,
+			message
+		});
+		this[_a15] = true;
+		this.functionality = functionality;
+	}
+	static isInstance(error) {
+		return AISDKError.hasMarker(error, marker15);
+	}
+});
+//#endregion
+//#region src/model/fallback-model.ts
+const RETRYABLE_MESSAGE_PATTERNS = [
+	/ECONNREFUSED/i,
+	/ECONNRESET/i,
+	/ETIMEDOUT/i,
+	/EAI_AGAIN/i,
+	/ENOTFOUND/i,
+	/timed?\s*out/i,
+	/network/i,
+	/fetch failed/i
+];
+function isRetryableError(error) {
+	if (APICallError.isInstance(error)) {
+		if (typeof error.statusCode === "number") return error.statusCode === 429 || error.statusCode >= 500;
+		return error.isRetryable;
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	return RETRYABLE_MESSAGE_PATTERNS.some((pattern) => pattern.test(message));
 }
 /**
-* Parses AI-generated text into structured data validated against a Zod schema.
+* Creates a `LanguageModelV4` that transparently falls back to a secondary
+* model when the primary model fails with a retryable error (HTTP 429, 5xx,
+* network errors/timeouts). Non-retryable errors (400s, validation, abort)
+* propagate unchanged.
 *
-* Handles common AI response formats:
-* - JSON wrapped in markdown code blocks
-* - JSON embedded in prose text
-* - Malformed JSON (auto-repaired)
-* - Escaped unicode and special characters
-*
-* @param text - The raw AI response text
-* @param schema - A Zod schema to validate and type the result
-* @returns The parsed and validated data
-* @throws {ParseObjectError} When parsing or validation fails
+* This is a model, not a middleware — middleware cannot switch the
+* underlying model, only transform a single model's behavior.
 *
 * @example
 * ```ts
-* const schema = z.object({ title: z.string(), tags: z.array(z.string()) });
-* const result = parseObject(aiResponse, schema);
-* // result is typed as { title: string; tags: string[] }
+* const model = createFallbackModel({
+*   primary: provider.model('anthropic/claude-sonnet-4'),
+*   fallback: provider.model('openai/gpt-4o-mini'),
+*   logger,
+* });
 * ```
 */
-function parseObject(text, schema) {
-	try {
-		const unescaped = unescapeJsonValues(extractBySchemaType(extractJsonString(text), schema, text));
-		return schema.parse(unescaped);
-	} catch (error) {
-		if (error instanceof ParseObjectError) throw error;
-		if (error instanceof z.ZodError) throw new ParseObjectError("Failed to validate response against schema", error, text);
-		throw error;
+function createFallbackModel(options) {
+	const { primary, fallback, logger } = options;
+	const primaryModel = primary;
+	const fallbackModel = fallback;
+	function logFallback(error) {
+		logger?.warn("ai.fallback.triggered", {
+			modelIds: [primaryModel.modelId, fallbackModel.modelId],
+			error: error instanceof Error ? error.message : String(error)
+		});
 	}
+	return {
+		specificationVersion: "v4",
+		provider: primaryModel.provider,
+		modelId: primaryModel.modelId,
+		supportedUrls: primaryModel.supportedUrls,
+		async doGenerate(callOptions) {
+			try {
+				return await primaryModel.doGenerate(callOptions);
+			} catch (error) {
+				if (!isRetryableError(error)) throw error;
+				logFallback(error);
+				return fallbackModel.doGenerate(callOptions);
+			}
+		},
+		async doStream(callOptions) {
+			try {
+				return await primaryModel.doStream(callOptions);
+			} catch (error) {
+				if (!isRetryableError(error)) throw error;
+				logFallback(error);
+				return fallbackModel.doStream(callOptions);
+			}
+		}
+	};
 }
 //#endregion
-//#region src/generation/generate-structured.ts
+//#region src/middleware/schema-instruction.middleware.ts
+function buildInstruction(responseFormat) {
+	if (responseFormat?.type !== "json") return "";
+	const lines = ["You must respond with valid JSON only — no prose, no markdown code fences."];
+	if (responseFormat.schema) lines.push("The JSON must strictly conform to this JSON schema:", JSON.stringify(responseFormat.schema));
+	return lines.join("\n");
+}
+function appendToLastUserMessage(prompt, instruction) {
+	const lastUserIndex = prompt.findLastIndex((message) => message.role === "user");
+	if (lastUserIndex === -1) return [...prompt, {
+		content: [{
+			text: instruction,
+			type: "text"
+		}],
+		role: "user"
+	}];
+	return prompt.map((message, index) => {
+		if (index !== lastUserIndex || message.role !== "user") return message;
+		const lastTextIndex = message.content.findLastIndex((part) => part.type === "text");
+		if (lastTextIndex === -1) return {
+			...message,
+			content: [...message.content, {
+				text: instruction,
+				type: "text"
+			}]
+		};
+		return {
+			...message,
+			content: message.content.map((part, partIndex) => {
+				if (partIndex !== lastTextIndex || part.type !== "text") return part;
+				return {
+					...part,
+					text: `${part.text}\n\n${instruction}`
+				};
+			})
+		};
+	});
+}
 /**
-* Generate structured data from an AI model with automatic parsing and error handling.
-* Observability is handled by middleware - no metadata exposed to caller.
+* Creates middleware that injects the JSON schema of a structured-output
+* request into the last user message.
+*
+* Some gateways silently drop the native structured-output field when
+* translating to their backend, so the model never sees the schema and
+* answers in free prose. This middleware re-states the schema as part of the
+* user message so structured output works regardless. It targets the user
+* message rather than a system message because gateways backed by cloaked
+* CLI agents bury injected system messages under their own persona prompt and
+* ignore them. The original `responseFormat` is left untouched: backends that
+* honor it get the native signal too.
+*
+* No-op for text generations (no `responseFormat`, or `type: 'text'`).
 */
-async function generateStructured(options) {
-	const { model, prompt, system, schema, providerOptions, abortSignal, maxOutputTokens, temperature } = options;
-	try {
-		const response = await generateText({
-			model,
-			prompt,
-			system,
-			providerOptions,
-			abortSignal,
-			maxOutputTokens,
-			temperature
-		});
-		if (!response.text || response.text.trim() === "") return generationFailure("EMPTY_RESULT", "AI returned empty response");
-		try {
-			return generationSuccess(parseObject(response.text, schema));
-		} catch (error) {
-			if (error instanceof ParseObjectError) return generationFailure("PARSING_FAILED", error.message, error);
-			return generationFailure("VALIDATION_FAILED", "Schema validation failed", error);
+function createSchemaInstructionMiddleware() {
+	return {
+		specificationVersion: "v4",
+		transformParams: ({ params }) => {
+			const instruction = buildInstruction(params.responseFormat);
+			if (!instruction) return Promise.resolve(params);
+			return Promise.resolve({
+				...params,
+				prompt: appendToLastUserMessage(params.prompt, instruction)
+			});
 		}
-	} catch (error) {
-		return generationFailure(classifyError(error), error instanceof Error ? error.message : "Unknown error", error);
-	}
+	};
 }
 //#endregion
-//#region src/parsing/create-schema-prompt.ts
+//#region src/provider/gateway.provider.ts
 /**
-* Creates a system prompt that instructs the model to output structured data
-* matching the provided Zod schema.
-*
-* Use this with `generateText` when the provider doesn't support native
-* structured outputs, then parse the response with `parseObject`.
+* Creates a provider for gateways exposing a chat-completions API — any API
+* implementing the OpenAI chat completions spec.
 *
-* @param schema - A Zod schema defining the expected output structure
-* @returns A system prompt string with JSON schema instructions
+* Every model returned is automatically wrapped with two safety nets for
+* gateways that don't support native structured output:
+* - `createSchemaInstructionMiddleware` injects the JSON schema into the
+*   system prompt (some gateways silently drop `response_format`);
+* - `extractJsonMiddleware` strips markdown code fences from JSON responses.
 *
 * @example
 * ```ts
-* import { generateText } from 'ai';
-* import { createSchemaPrompt, parseObject } from '@jterrazz/intelligence';
-*
-* const schema = z.object({ title: z.string(), tags: z.array(z.string()) });
-*
-* const { text } = await generateText({
-*   model,
-*   prompt: 'Generate an article about TypeScript',
-*   system: createSchemaPrompt(schema),
-* });
+* const provider = createGatewayProvider({ baseURL: 'https://gateway.example.com/v1' });
+* const model = provider.model('gpt-4o-mini');
 *
-* const result = parseObject(text, schema);
+* const { text } = await generateText({ model, prompt: 'Hello!' });
 * ```
 */
-function createSchemaPrompt(schema) {
-	const jsonSchema = z.toJSONSchema(schema);
-	const schemaJson = JSON.stringify(jsonSchema, null, 2);
-	if ([
-		"boolean",
-		"integer",
-		"number",
-		"string"
-	].includes(jsonSchema.type)) return `<OUTPUT_FORMAT>
-You must respond with a ${jsonSchema.type} value that matches this schema:
-
-\`\`\`json
-${schemaJson}
-\`\`\`
-
-Your response should be only the ${jsonSchema.type} value, without any JSON wrapping or additional text.
-</OUTPUT_FORMAT>`;
-	return `<OUTPUT_FORMAT>
-You must respond with valid JSON that matches this JSON schema:
-
-\`\`\`json
-${schemaJson}
-\`\`\`
-
-Your response must be parseable JSON that validates against this schema. Do not include any text outside the JSON.
-</OUTPUT_FORMAT>`;
+function createGatewayProvider(config) {
+	const openai = createOpenAI({
+		apiKey: config.apiKey,
+		baseURL: config.baseURL
+	});
+	return { model(id) {
+		return wrapLanguageModel({
+			model: openai.chat(id),
+			middleware: [createSchemaInstructionMiddleware(), extractJsonMiddleware()]
+		});
+	} };
 }
 //#endregion
 //#region src/provider/openrouter.provider.ts
 /**
 * Creates an OpenRouter provider for AI SDK models.
 *
+* Per-call options (reasoning effort, max tokens, etc.) are no longer
+* configured here — pass them at the call site via `providerOptions.openrouter`
+* on `generateText`/`streamText`.
+*
 * @example
 * ```ts
 * const provider = createOpenRouterProvider({ apiKey: process.env.OPENROUTER_API_KEY });
 * const model = provider.model('anthropic/claude-sonnet-4-20250514');
 *
-* const { text } = await generateText({ model, prompt: 'Hello!' });
+* const { text } = await generateText({
+*   model,
+*   prompt: 'Hello!',
+*   providerOptions: { openrouter: { reasoning: { effort: 'high' } } },
+* });
 * ```
 */
 function createOpenRouterProvider(config) {
-	const openrouter = createOpenRouter({ apiKey: config.apiKey });
-	return { model(name, options = {}) {
-		return openrouter(name, {
-			...options.maxTokens !== void 0 && { maxTokens: options.maxTokens },
-			...options.reasoning && { extraBody: { reasoning: options.reasoning } }
-		});
+	const openrouter = createOpenRouter({
+		apiKey: config.apiKey,
+		appName: config.metadata?.application,
+		appUrl: config.metadata?.website
+	});
+	return { model(id) {
+		return openrouter(id);
 	} };
 }
 //#endregion
-//#region src/provider/openrouter-metadata.adapter.ts
+//#region src/factory/create-intelligence.ts
+let telemetryRegistered = false;
 /**
-* OpenRouter adapter for extracting usage and cost from provider metadata
+* Registers the AI SDK OpenTelemetry integration, once per process. Best
+* effort — if the host app has no OTel SDK configured, `@ai-sdk/otel` spans
+* are simply dropped rather than throwing.
 */
-var OpenRouterMetadataAdapter = class {
-	extract(providerMetadata) {
-		const meta = providerMetadata?.openrouter;
-		if (!meta?.usage) return {};
-		const usage = meta.usage;
-		return {
-			usage: {
-				input: usage.promptTokens ?? 0,
-				output: usage.completionTokens ?? 0,
-				total: usage.totalTokens,
-				reasoning: usage.completionTokensDetails?.reasoningTokens,
-				cacheRead: usage.promptTokensDetails?.cachedTokens
-			},
-			cost: usage.cost !== void 0 ? { total: usage.cost } : void 0
-		};
+function ensureTelemetryRegistered() {
+	if (telemetryRegistered) return;
+	telemetryRegistered = true;
+	try {
+		registerTelemetry(new OpenTelemetry());
+	} catch {}
+}
+function createProvider(config) {
+	switch (config.type) {
+		case "gateway": return createGatewayProvider(config);
+		case "openrouter": return createOpenRouterProvider(config);
 	}
-};
-//#endregion
-//#region src/provider/openai-compatible.provider.ts
-/**
-* Creates a provider for OpenAI-compatible APIs.
-* Works with any API implementing the OpenAI chat completions spec.
-*/
-function createOpenAICompatibleProvider(config) {
-	const openai = createOpenAI({
-		apiKey: config.apiKey,
-		baseURL: config.baseURL
-	});
-	return { model(name, _options = {}) {
-		const modelName = config.modelMapping?.[name] ?? name;
-		return openai(modelName);
-	} };
 }
-//#endregion
-//#region src/provider/openai-compatible-metadata.adapter.ts
+function assertProviderExists(providerKey, providers) {
+	if (providers[providerKey]) return;
+	const available = Object.keys(providers).join(", ") || "(none configured)";
+	throw new Error(`Unknown provider "${providerKey}". Available providers: ${available}.`);
+}
 /**
-* Metadata adapter for OpenAI-compatible APIs (including gateway-intelligence).
-* Extracts usage data from the standardized OpenAI response format.
+* Creates a composition root over AI SDK v7: resolves each agent's
+* `provider`/`model` pair into a fully instrumented `LanguageModel` — cost
+* tracking, optional fallback, and optional logging — cached per agent name.
+*
+* Registers the `@ai-sdk/otel` telemetry integration on first use (idempotent,
+* best-effort). The host app is expected to have already registered an
+* OpenTelemetry Node SDK (e.g. via `@jterrazz/telemetry`).
+*
+* @example
+* ```ts
+* const intelligence = createIntelligence({
+*   providers: {
+*     openrouter: { type: 'openrouter', apiKey: process.env.OPENROUTER_API_KEY },
+*   },
+*   agents: {
+*     summarizer: {
+*       provider: 'openrouter',
+*       model: 'google/gemini-2.5-flash-lite',
+*       fallback: { provider: 'openrouter', model: 'openai/gpt-4o-mini' },
+*     },
+*   },
+*   pricing: {
+*     'openrouter/google/gemini-2.5-flash-lite': { input: 0.1, output: 0.4 },
+*   },
+*   logger,
+* });
+*
+* const model = intelligence.model('summarizer');
+* const { text } = await generateText({ model, prompt: 'Hello!' });
+* ```
 */
-var OpenAICompatibleMetadataAdapter = class {
-	extract(providerMetadata) {
-		const meta = providerMetadata?.openai;
-		if (!meta?.usage) return {};
-		const usage = meta.usage;
-		return { usage: {
-			input: usage.promptTokens ?? 0,
-			output: usage.completionTokens ?? 0,
-			total: usage.totalTokens
-		} };
+function createIntelligence(config) {
+	ensureTelemetryRegistered();
+	const { agents, logger, pricing, providers } = config;
+	const providerCache = /* @__PURE__ */ new Map();
+	const modelCache = /* @__PURE__ */ new Map();
+	function resolveProvider(providerKey) {
+		let provider = providerCache.get(providerKey);
+		if (!provider) {
+			provider = createProvider(providers[providerKey]);
+			providerCache.set(providerKey, provider);
+		}
+		return provider;
 	}
-};
+	function buildModel(ref, agentName) {
+		assertProviderExists(ref.provider, providers);
+		return wrapLanguageModel({
+			model: resolveProvider(ref.provider).model(ref.model),
+			middleware: [createAgentMiddleware({ agentName }), createCostMiddleware({ pricing: pricing?.[`${ref.provider}/${ref.model}`] })]
+		});
+	}
+	function buildAgentModel(agentName) {
+		const agentConfig = agents[agentName];
+		if (!agentConfig) {
+			const available = Object.keys(agents).join(", ") || "(none configured)";
+			throw new Error(`Unknown agent "${agentName}". Available agents: ${available}.`);
+		}
+		const primary = buildModel({
+			model: agentConfig.model,
+			provider: agentConfig.provider
+		}, agentName);
+		const composed = agentConfig.fallback ? createFallbackModel({
+			fallback: buildModel(agentConfig.fallback, agentName),
+			logger,
+			primary
+		}) : primary;
+		if (!logger) return composed;
+		return wrapLanguageModel({
+			model: composed,
+			middleware: [createLoggingMiddleware({ logger })]
+		});
+	}
+	return { model(agentName) {
+		let model = modelCache.get(agentName);
+		if (!model) {
+			model = buildAgentModel(agentName);
+			modelCache.set(agentName, model);
+		}
+		return model;
+	} };
+}
 //#endregion
-export { LangfuseAdapter, NoopObservabilityAdapter, OpenAICompatibleMetadataAdapter, OpenRouterMetadataAdapter, ParseObjectError, classifyError, createLoggingMiddleware, createObservabilityMiddleware, createOpenAICompatibleProvider, createOpenRouterProvider, createSchemaPrompt, generateStructured, generationFailure, generationSuccess, isFailure, isSuccess, parseObject, parseText, unwrap, unwrapOr, withObservability };
+export { createAgentMiddleware, createCostMiddleware, createFallbackModel, createGatewayProvider, createIntelligence, createLoggingMiddleware, createOpenRouterProvider, createSchemaInstructionMiddleware };
 
 //# sourceMappingURL=index.js.map