@jterrazz/intelligence 3.0.1 → 4.0.0

package/dist/index.cjs

@@ -1,829 +1,640 @@
-'use strict';
+let langfuse = require("langfuse");
+let ai = require("ai");
+let jsonrepair = require("jsonrepair");
+let zod_v4 = require("zod/v4");
+let _openrouter_ai_sdk_provider = require("@openrouter/ai-sdk-provider");
 
-var v4 = require('zod/v4');
-var jsonrepair = require('jsonrepair');
-var aiSdkProvider = require('@openrouter/ai-sdk-provider');
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _define_property$2(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _instanceof$1(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
-    }
-}
-function _object_spread$1(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property$2(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
+//#region src/logging/logging.middleware.ts
+/**
+* Creates middleware that logs AI SDK requests and responses.
+*/
+function createLoggingMiddleware(options) {
+	const { logger, include = {} } = options;
+	const { params: includeParams, content: includeContent, usage: includeUsage = true } = include;
+	return {
+		specificationVersion: "v3",
+		wrapGenerate: async ({ doGenerate, params, model }) => {
+			const startTime = Date.now();
+			logger.debug("ai.generate.start", {
+				model: model.modelId,
+				...includeParams && { params }
+			});
+			try {
+				const result = await doGenerate();
+				const textContent = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+				logger.debug("ai.generate.complete", {
+					model: model.modelId,
+					durationMs: Date.now() - startTime,
+					finishReason: result.finishReason,
+					...includeUsage && { usage: result.usage },
+					...includeContent && { content: textContent }
+				});
+				return result;
+			} catch (error) {
+				logger.error("ai.generate.error", {
+					model: model.modelId,
+					durationMs: Date.now() - startTime,
+					error: error instanceof Error ? error.message : "Unknown error"
+				});
+				throw error;
+			}
+		},
+		wrapStream: async ({ doStream, params, model }) => {
+			const startTime = Date.now();
+			logger.debug("ai.stream.start", {
+				model: model.modelId,
+				...includeParams && { params }
+			});
+			try {
+				const result = await doStream();
+				const chunks = [];
+				const transformStream = new TransformStream({
+					transform(chunk, controller) {
+						if (includeContent && chunk.type === "text-delta") chunks.push(chunk.delta);
+						controller.enqueue(chunk);
+					},
+					flush() {
+						logger.debug("ai.stream.complete", {
+							model: model.modelId,
+							durationMs: Date.now() - startTime,
+							...includeContent && { content: chunks.join("") }
+						});
+					}
+				});
+				return {
+					specificationVersion: "v3",
+					...result,
+					stream: result.stream.pipeThrough(transformStream)
+				};
+			} catch (error) {
+				logger.error("ai.stream.error", {
+					model: model.modelId,
+					durationMs: Date.now() - startTime,
+					error: error instanceof Error ? error.message : "Unknown error"
+				});
+				throw error;
+			}
+		}
+	};
 }
-function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
+
+//#endregion
+//#region src/observability/observability.middleware.ts
+/**
+* Helper to create type-safe observability metadata for providerOptions
+*/
+function withObservability(meta) {
+	return { observability: meta };
 }
 /**
- * Creates AI SDK middleware that logs model requests and responses.
- *
- * @example
- * ```ts
- * import { wrapLanguageModel } from 'ai';
- *
- * const model = wrapLanguageModel({
- *   model: openrouter('anthropic/claude-sonnet-4-20250514'),
- *   middleware: createLoggingMiddleware({ logger }),
- * });
- * ```
- */ function createLoggingMiddleware(options) {
-    var logger = options.logger, _options_verbose = options.verbose, verbose = _options_verbose === void 0 ? false : _options_verbose;
-    return {
-        middlewareVersion: 'v2',
-        wrapGenerate: function(param) {
-            var doGenerate = param.doGenerate, params = param.params;
-            return _async_to_generator(function() {
-                var startTime, result, error;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            startTime = Date.now();
-                            logger.debug('Model request started', _object_spread$1({}, verbose && {
-                                params: params
-                            }));
-                            _state.label = 1;
-                        case 1:
-                            _state.trys.push([
-                                1,
-                                3,
-                                ,
-                                4
-                            ]);
-                            return [
-                                4,
-                                doGenerate()
-                            ];
-                        case 2:
-                            result = _state.sent();
-                            logger.debug('Model request completed', _object_spread$1({
-                                durationMs: Date.now() - startTime,
-                                finishReason: result.finishReason,
-                                usage: result.usage
-                            }, verbose && {
-                                content: result.content
-                            }));
-                            return [
-                                2,
-                                result
-                            ];
-                        case 3:
-                            error = _state.sent();
-                            logger.error('Model request failed', {
-                                durationMs: Date.now() - startTime,
-                                error: _instanceof$1(error, Error) ? error.message : 'Unknown error'
-                            });
-                            throw error;
-                        case 4:
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        },
-        wrapStream: function(param) {
-            var doStream = param.doStream, params = param.params;
-            return _async_to_generator(function() {
-                var startTime, result, error;
-                return _ts_generator(this, function(_state) {
-                    switch(_state.label){
-                        case 0:
-                            startTime = Date.now();
-                            logger.debug('Model stream started', _object_spread$1({}, verbose && {
-                                params: params
-                            }));
-                            _state.label = 1;
-                        case 1:
-                            _state.trys.push([
-                                1,
-                                3,
-                                ,
-                                4
-                            ]);
-                            return [
-                                4,
-                                doStream()
-                            ];
-                        case 2:
-                            result = _state.sent();
-                            return [
-                                2,
-                                _object_spread_props(_object_spread$1({}, result), {
-                                    stream: result.stream
-                                })
-                            ];
-                        case 3:
-                            error = _state.sent();
-                            logger.error('Model stream failed', {
-                                durationMs: Date.now() - startTime,
-                                error: _instanceof$1(error, Error) ? error.message : 'Unknown error'
-                            });
-                            throw error;
-                        case 4:
-                            return [
-                                2
-                            ];
-                    }
-                });
-            })();
-        }
-    };
+* Creates middleware that sends generation data to an observability platform.
+*/
+function createObservabilityMiddleware(options) {
+	const { observability, providerMetadata } = options;
+	return {
+		specificationVersion: "v3",
+		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: "v3",
+				...result,
+				stream: result.stream.pipeThrough(transformStream)
+			};
+		}
+	};
 }
 
+//#endregion
+//#region src/observability/langfuse.adapter.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`.
- *
- * @param schema - A Zod schema defining the expected output structure
- * @returns A system prompt string with JSON schema instructions
- *
- * @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 result = parseObject(text, schema);
- * ```
- */ function createSchemaPrompt(schema) {
-    var jsonSchema = v4.z.toJSONSchema(schema);
-    var schemaJson = JSON.stringify(jsonSchema, null, 2);
-    var isPrimitive = [
-        'boolean',
-        'integer',
-        'number',
-        'string'
-    ].includes(jsonSchema.type);
-    if (isPrimitive) {
-        return "<OUTPUT_FORMAT>\nYou must respond with a ".concat(jsonSchema.type, " value that matches this schema:\n\n```json\n").concat(schemaJson, "\n```\n\nYour response should be only the ").concat(jsonSchema.type, " value, without any JSON wrapping or additional text.\n</OUTPUT_FORMAT>");
-    }
-    return "<OUTPUT_FORMAT>\nYou must respond with valid JSON that matches this JSON schema:\n\n```json\n".concat(schemaJson, "\n```\n\nYour response must be parseable JSON that validates against this schema. Do not include any text outside the JSON.\n</OUTPUT_FORMAT>");
-}
+* Langfuse adapter implementing ObservabilityPort
+*/
+var LangfuseAdapter = class {
+	client;
+	constructor(config) {
+		this.client = new langfuse.Langfuse({
+			secretKey: config.secretKey,
+			publicKey: config.publicKey,
+			baseUrl: config.baseUrl,
+			environment: config.environment,
+			release: config.release
+		});
+	}
+	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
+		});
+	}
+	async shutdown() {
+		await this.client.shutdownAsync();
+	}
+	trace(params) {
+		this.client.trace({
+			id: params.id,
+			name: params.name,
+			metadata: params.metadata
+		});
+	}
+};
 
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_with_holes(arr) {
-    if (Array.isArray(arr)) return arr;
-}
-function _assert_this_initialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    }
-    return self;
-}
-function _call_super(_this, derived, args) {
-    derived = _get_prototype_of(derived);
-    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
-}
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _construct(Parent, args, Class) {
-    if (_is_native_reflect_construct()) {
-        _construct = Reflect.construct;
-    } else {
-        _construct = function construct(Parent, args, Class) {
-            var a = [
-                null
-            ];
-            a.push.apply(a, args);
-            var Constructor = Function.bind.apply(Parent, a);
-            var instance = new Constructor();
-            if (Class) _set_prototype_of(instance, Class.prototype);
-            return instance;
-        };
-    }
-    return _construct.apply(null, arguments);
-}
-function _define_property$1(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _get_prototype_of(o) {
-    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _get_prototype_of(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
-    });
-    if (superClass) _set_prototype_of(subClass, superClass);
-}
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
-    }
-}
-function _is_native_function(fn) {
-    return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-function _iterable_to_array_limit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
-    }
-    return _arr;
-}
-function _non_iterable_rest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _possible_constructor_return(self, call) {
-    if (call && (_type_of(call) === "object" || typeof call === "function")) {
-        return call;
-    }
-    return _assert_this_initialized(self);
-}
-function _set_prototype_of(o, p) {
-    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _set_prototype_of(o, p);
-}
-function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+//#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
+	};
 }
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+/**
+* Create a failed result
+*/
+function generationFailure(code, message, cause) {
+	return {
+		success: false,
+		error: {
+			code,
+			message,
+			cause
+		}
+	};
 }
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+/**
+* 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";
 }
-function _wrap_native_super(Class) {
-    var _cache = typeof Map === "function" ? new Map() : undefined;
-    _wrap_native_super = function wrapNativeSuper(Class) {
-        if (Class === null || !_is_native_function(Class)) return Class;
-        if (typeof Class !== "function") {
-            throw new TypeError("Super expression must either be null or a function");
-        }
-        if (typeof _cache !== "undefined") {
-            if (_cache.has(Class)) return _cache.get(Class);
-            _cache.set(Class, Wrapper);
-        }
-        function Wrapper() {
-            return _construct(Class, arguments, _get_prototype_of(this).constructor);
-        }
-        Wrapper.prototype = Object.create(Class.prototype, {
-            constructor: {
-                value: Wrapper,
-                enumerable: false,
-                writable: true,
-                configurable: true
-            }
-        });
-        return _set_prototype_of(Wrapper, Class);
-    };
-    return _wrap_native_super(Class);
+/**
+* Check if a result is successful (type guard)
+*/
+function isSuccess(result) {
+	return result.success;
 }
-function _is_native_reflect_construct() {
-    try {
-        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-    } catch (_) {}
-    return (_is_native_reflect_construct = function() {
-        return !!result;
-    })();
+/**
+* Check if a result is a failure (type guard)
+*/
+function isFailure(result) {
+	return !result.success;
 }
 /**
- * Error thrown when object parsing fails.
- * Contains the original text for debugging purposes.
- */ var ParseObjectError = /*#__PURE__*/ function(Error1) {
-    _inherits(ParseObjectError, Error1);
-    function ParseObjectError(message, cause, text) {
-        _class_call_check(this, ParseObjectError);
-        var _this;
-        _this = _call_super(this, ParseObjectError, [
-            message
-        ]), _define_property$1(_this, "cause", void 0), _define_property$1(_this, "text", void 0), _define_property$1(_this, "name", void 0), _this.cause = cause, _this.text = text, _this.name = 'ParseObjectError';
-        return _this;
-    }
-    return ParseObjectError;
-}(_wrap_native_super(Error));
+* 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}`);
+}
 /**
- * Parses AI-generated text into structured data validated against a Zod schema.
- *
- * 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
- *
- * @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[] }
- * ```
- */ function parseObject(text, schema) {
-    try {
-        var jsonString = extractJsonString(text);
-        var extracted = extractBySchemaType(jsonString, schema, text);
-        var unescaped = unescapeJsonValues(extracted);
-        return schema.parse(unescaped);
-    } catch (error) {
-        if (_instanceof(error, ParseObjectError)) {
-            throw error;
-        }
-        if (_instanceof(error, v4.z.ZodError)) {
-            throw new ParseObjectError('Failed to validate response against schema', error, text);
-        }
-        throw error;
-    }
+* Unwrap a result with a default value for failures
+*/
+function unwrapOr(result, defaultValue) {
+	return result.success ? result.data : defaultValue;
 }
-var MARKDOWN_CODE_BLOCK_RE = /```(?:json)?\r?\n([^`]*?)\r?\n```/g;
+
+//#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";
+	constructor(message, cause, text) {
+		super(message);
+		this.cause = cause;
+		this.text = text;
+	}
+};
 function convertToPrimitive(value, schema) {
-    if (_instanceof(schema, v4.z.ZodBoolean)) return Boolean(value);
-    if (_instanceof(schema, v4.z.ZodNull)) return null;
-    if (_instanceof(schema, v4.z.ZodNumber)) return Number(value);
-    if (_instanceof(schema, v4.z.ZodString)) return String(value);
-    return value;
+	if (schema instanceof zod_v4.z.ZodBoolean) return Boolean(value);
+	if (schema instanceof zod_v4.z.ZodNull) return null;
+	if (schema instanceof zod_v4.z.ZodNumber) return Number(value);
+	if (schema instanceof zod_v4.z.ZodString) return String(value);
+	return value;
 }
 function extractArray(text, originalText) {
-    var start = text.indexOf('[');
-    var end = text.lastIndexOf(']');
-    if (start === -1 || end === -1) {
-        throw new ParseObjectError('No array found in response', undefined, originalText);
-    }
-    try {
-        var raw = text.slice(start, end + 1);
-        return JSON.parse(jsonrepair.jsonrepair(raw));
-    } catch (error) {
-        throw new ParseObjectError('Failed to parse array JSON', error, 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((0, jsonrepair.jsonrepair)(raw));
+	} catch (error) {
+		throw new ParseObjectError("Failed to parse array JSON", error, originalText);
+	}
 }
-function extractBySchemaType(text, schema, originalText) {
-    if (_instanceof(schema, v4.z.ZodArray)) {
-        return extractArray(text, originalText);
-    }
-    if (_instanceof(schema, v4.z.ZodObject)) {
-        return extractObject(text, originalText);
-    }
-    if (_instanceof(schema, v4.z.ZodBoolean) || _instanceof(schema, v4.z.ZodNull) || _instanceof(schema, v4.z.ZodNumber) || _instanceof(schema, v4.z.ZodString)) {
-        return extractPrimitive(text, schema);
-    }
-    throw new ParseObjectError('Unsupported schema type', undefined, originalText);
+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((0, jsonrepair.jsonrepair)(raw));
+	} catch (error) {
+		throw new ParseObjectError("Failed to parse object JSON", error, originalText);
+	}
 }
-function extractJsonFromCodeBlock(block) {
-    var content = block.replace(/```(?:json)?\r?\n([^`]*?)\r?\n```/, '$1').trim();
-    try {
-        JSON.parse(content);
-        return content;
-    } catch (e) {
-        return null;
-    }
+function extractPrimitive(text, schema) {
+	const trimmed = text.trim();
+	try {
+		return convertToPrimitive(JSON.parse(trimmed), schema);
+	} catch {
+		return convertToPrimitive(trimmed, schema);
+	}
 }
-function extractJsonString(text) {
-    var codeBlocks = text.match(MARKDOWN_CODE_BLOCK_RE);
-    if (codeBlocks && codeBlocks.length > 0) {
-        var validBlocks = codeBlocks.map(function(block) {
-            return extractJsonFromCodeBlock(block);
-        }).filter(function(block) {
-            return block !== null;
-        });
-        if (validBlocks.length > 0) {
-            return findLongestString(validBlocks);
-        }
-    }
-    var structures = findJsonStructures(text);
-    if (structures.length > 0) {
-        return findLongestString(structures);
-    }
-    return text.replace(/\s+/g, ' ').trim();
+function extractBySchemaType(text, schema, originalText) {
+	if (schema instanceof zod_v4.z.ZodArray) return extractArray(text, originalText);
+	if (schema instanceof zod_v4.z.ZodObject) return extractObject(text, originalText);
+	if (schema instanceof zod_v4.z.ZodBoolean || schema instanceof zod_v4.z.ZodNull || schema instanceof zod_v4.z.ZodNumber || schema instanceof zod_v4.z.ZodString) return extractPrimitive(text, schema);
+	if (schema instanceof zod_v4.z.ZodUnion || schema instanceof zod_v4.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 zod_v4.z.ZodOptional || schema instanceof zod_v4.z.ZodNullable) return extractBySchemaType(text, schema.unwrap(), originalText);
+	if (schema instanceof zod_v4.z.ZodDefault) return extractBySchemaType(text, schema.def.innerType, originalText);
+	if (schema instanceof zod_v4.z.ZodPipe) return extractBySchemaType(text, schema.def.in, originalText);
+	throw new ParseObjectError("Unsupported schema type", void 0, originalText);
 }
-function extractObject(text, originalText) {
-    var start = text.indexOf('{');
-    var end = text.lastIndexOf('}');
-    if (start === -1 || end === -1) {
-        throw new ParseObjectError('No object found in response', undefined, originalText);
-    }
-    try {
-        var raw = text.slice(start, end + 1);
-        return JSON.parse(jsonrepair.jsonrepair(raw));
-    } catch (error) {
-        throw new ParseObjectError('Failed to parse object JSON', error, originalText);
-    }
+function extractJsonFromCodeBlock(block) {
+	const content = block.replace(/```(?:json)?\r?\n([^`]*?)\r?\n```/, "$1").trim();
+	try {
+		JSON.parse(content);
+		return content;
+	} catch {
+		return null;
+	}
 }
-function extractPrimitive(text, schema) {
-    var trimmed = text.trim();
-    try {
-        return convertToPrimitive(JSON.parse(trimmed), schema);
-    } catch (e) {
-        return convertToPrimitive(trimmed, schema);
-    }
+function findLongestString(strings) {
+	return strings.reduce((longest, current) => current.length > longest.length ? current : longest);
 }
 function findJsonStructures(text) {
-    var matches = [];
-    var depth = 0;
-    var start = -1;
-    for(var i = 0; i < text.length; i++){
-        var _char = text[i];
-        if (_char === '{' || _char === '[') {
-            if (depth === 0) start = i;
-            depth++;
-        } else if (_char === '}' || _char === ']') {
-            depth--;
-            if (depth === 0 && start !== -1) {
-                var candidate = text.slice(start, i + 1);
-                try {
-                    JSON.parse(candidate);
-                    matches.push(candidate);
-                } catch (e) {
-                // Invalid JSON, skip
-                }
-            }
-        }
-    }
-    return matches;
+	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 {}
+			}
+		}
+	}
+	return matches;
 }
-function findLongestString(strings) {
-    return strings.reduce(function(longest, current) {
-        return current.length > longest.length ? current : longest;
-    });
+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 === "undefined" ? "undefined" : _type_of(json)) === 'object' && json !== null) {
-        return Object.fromEntries(Object.entries(json).map(function(param) {
-            var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
-            return [
-                key,
-                unescapeJsonValues(value)
-            ];
-        }));
-    }
-    return 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;
 }
-function unescapeString(text) {
-    return text.replace(/\\"/g, '"').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\\\/g, '\\').replace(/\\u([0-9a-fA-F]{4})/g, function(_, code) {
-        return String.fromCharCode(Number.parseInt(code, 16));
-    });
+/**
+* Parses AI-generated text into structured data validated against a Zod schema.
+*
+* 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
+*
+* @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[] }
+* ```
+*/
+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 zod_v4.z.ZodError) throw new ParseObjectError("Failed to validate response against schema", error, text);
+		throw error;
+	}
 }
 
-var INVISIBLE_CHARS_RE = /[\u00AD\u180E\u200B-\u200C\u200E-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/g;
-/* eslint-disable no-control-regex -- intentionally matching control characters */ // biome-ignore lint/suspicious/noControlCharactersInRegex: intentionally matching control characters for sanitization
-var ASCII_CTRL_RE = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g;
-/* eslint-enable no-control-regex */ var SPACE_LIKE_RE = /[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
-var MULTIPLE_SPACES_RE = / {2,}/g;
-var CR_RE = /\r\n?/g;
-var CITATION_RE = / *\(oaicite:\d+\)\{index=\d+\}/g;
-var EM_DASH_SEPARATOR_RE = /\s*[—–―‒]\s*/g;
-var TYPOGRAPHY_REPLACEMENTS = [
-    {
-        pattern: /[\u2018\u2019\u201A]/g,
-        replacement: "'"
-    },
-    {
-        pattern: /[\u201C\u201D\u201E]/g,
-        replacement: '"'
-    },
-    {
-        pattern: /\u2026/g,
-        replacement: '...'
-    },
-    {
-        pattern: /[\u2022\u25AA-\u25AB\u25B8-\u25B9\u25CF]/g,
-        replacement: '-'
-    }
-];
+//#endregion
+//#region src/generation/generate-structured.ts
 /**
- * Parses and sanitizes text by removing AI artifacts and normalizing typography.
- *
- * @param text - The text to parse
- * @param options - Parsing options
- * @returns The cleaned text
- */ function parseText(text) {
-    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-    var _options_normalizeEmDashesToCommas = options.normalizeEmDashesToCommas, normalizeEmDashesToCommas = _options_normalizeEmDashesToCommas === void 0 ? true : _options_normalizeEmDashesToCommas, _options_collapseSpaces = options.collapseSpaces, collapseSpaces = _options_collapseSpaces === void 0 ? true : _options_collapseSpaces;
-    if (!text) return '';
-    var result = text;
-    if (result.charCodeAt(0) === 0xfeff) {
-        result = result.slice(1);
-    }
-    result = result.replace(CR_RE, '\n');
-    result = result.replace(CITATION_RE, '');
-    result = result.normalize('NFKC');
-    result = result.replace(INVISIBLE_CHARS_RE, '');
-    result = result.replace(ASCII_CTRL_RE, '');
-    if (normalizeEmDashesToCommas) {
-        result = result.replace(EM_DASH_SEPARATOR_RE, ', ');
-    }
-    result = result.replace(SPACE_LIKE_RE, ' ');
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for(var _iterator = TYPOGRAPHY_REPLACEMENTS[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _step_value = _step.value, pattern = _step_value.pattern, replacement = _step_value.replacement;
-            result = result.replace(pattern, replacement);
-        }
-    } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-                _iterator["return"]();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
-    }
-    if (collapseSpaces) {
-        result = result.replace(MULTIPLE_SPACES_RE, ' ').trim();
-    }
-    return result;
+* Generate structured data from an AI model with automatic parsing and error handling.
+* Observability is handled by middleware - no metadata exposed to caller.
+*/
+async function generateStructured(options) {
+	const { model, prompt, system, schema, providerOptions, abortSignal, maxOutputTokens, temperature } = options;
+	try {
+		const response = await (0, ai.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);
+		}
+	} catch (error) {
+		return generationFailure(classifyError(error), error instanceof Error ? error.message : "Unknown error", error);
+	}
 }
 
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
+//#endregion
+//#region src/parsing/create-schema-prompt.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`.
+*
+* @param schema - A Zod schema defining the expected output structure
+* @returns A system prompt string with JSON schema instructions
+*
+* @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 result = parseObject(text, schema);
+* ```
+*/
+function createSchemaPrompt(schema) {
+	const jsonSchema = zod_v4.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 _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
+
+//#endregion
+//#region src/parsing/parse-text.ts
+const INVISIBLE_CHARS_RE = /[\u00AD\u180E\u200B-\u200C\u200E-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u2069\uFEFF]/g;
+const ASCII_CTRL_RE = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g;
+const SPACE_LIKE_RE = /[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
+const MULTIPLE_SPACES_RE = / {2,}/g;
+const CR_RE = /\r\n?/g;
+const CITATION_RE = / *\(oaicite:\d+\)\{index=\d+\}/g;
+const EM_DASH_SEPARATOR_RE = /\s*[—–―‒]\s*/g;
+const TYPOGRAPHY_REPLACEMENTS = [
+	{
+		pattern: /[\u2018\u2019\u201A]/g,
+		replacement: "'"
+	},
+	{
+		pattern: /[\u201C\u201D\u201E]/g,
+		replacement: "\""
+	},
+	{
+		pattern: /\u2026/g,
+		replacement: "..."
+	},
+	{
+		pattern: /[\u2022\u25AA-\u25AB\u25B8-\u25B9\u25CF]/g,
+		replacement: "-"
+	}
+];
+/**
+* Parses and sanitizes text by removing AI artifacts and normalizing typography.
+*
+* @param text - The text to parse
+* @param options - Parsing options
+* @returns The cleaned text
+*/
+function parseText(text, options = {}) {
+	const { normalizeEmDashesToCommas = true, collapseSpaces = true } = options;
+	if (!text) return "";
+	let result = text;
+	result = result.replace(CR_RE, "\n");
+	result = result.replace(CITATION_RE, "");
+	result = result.normalize("NFKC");
+	result = result.replace(INVISIBLE_CHARS_RE, "");
+	result = result.replace(ASCII_CTRL_RE, "");
+	if (normalizeEmDashesToCommas) result = result.replace(EM_DASH_SEPARATOR_RE, ", ");
+	result = result.replace(SPACE_LIKE_RE, " ");
+	for (const { pattern, replacement } of TYPOGRAPHY_REPLACEMENTS) result = result.replace(pattern, replacement);
+	if (collapseSpaces) result = result.replace(MULTIPLE_SPACES_RE, " ").trim();
+	return result;
 }
+
+//#endregion
+//#region src/provider/openrouter.provider.ts
 /**
- * Creates an OpenRouter provider for AI SDK models.
- *
- * @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!' });
- * ```
- */ function createOpenRouterProvider(config) {
-    var openrouter = aiSdkProvider.createOpenRouter({
-        apiKey: config.apiKey
-    });
-    return {
-        model: function model(name) {
-            var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-            return openrouter(name, _object_spread({}, options.maxTokens !== undefined && {
-                maxTokens: options.maxTokens
-            }, options.reasoning && {
-                extraBody: {
-                    reasoning: options.reasoning
-                }
-            }));
-        }
-    };
+* Creates an OpenRouter provider for AI SDK models.
+*
+* @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!' });
+* ```
+*/
+function createOpenRouterProvider(config) {
+	const openrouter = (0, _openrouter_ai_sdk_provider.createOpenRouter)({ apiKey: config.apiKey });
+	return { model(name, options = {}) {
+		return openrouter(name, {
+			...options.maxTokens !== void 0 && { maxTokens: options.maxTokens },
+			...options.reasoning && { extraBody: { reasoning: options.reasoning } }
+		});
+	} };
 }
 
+//#endregion
+//#region src/provider/openrouter-metadata.adapter.ts
+/**
+* OpenRouter adapter for extracting usage and cost from provider metadata
+*/
+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
+		};
+	}
+};
+
+//#endregion
+exports.LangfuseAdapter = LangfuseAdapter;
+exports.NoopObservabilityAdapter = NoopObservabilityAdapter;
+exports.OpenRouterMetadataAdapter = OpenRouterMetadataAdapter;
 exports.ParseObjectError = ParseObjectError;
+exports.classifyError = classifyError;
 exports.createLoggingMiddleware = createLoggingMiddleware;
+exports.createObservabilityMiddleware = createObservabilityMiddleware;
 exports.createOpenRouterProvider = createOpenRouterProvider;
 exports.createSchemaPrompt = createSchemaPrompt;
+exports.generateStructured = generateStructured;
+exports.generationFailure = generationFailure;
+exports.generationSuccess = generationSuccess;
+exports.isFailure = isFailure;
+exports.isSuccess = isSuccess;
 exports.parseObject = parseObject;
 exports.parseText = parseText;
+exports.unwrap = unwrap;
+exports.unwrapOr = unwrapOr;
+exports.withObservability = withObservability;
+//# sourceMappingURL=index.cjs.map