@jterrazz/intelligence 2.0.0 → 3.0.1

package/dist/parsing/parse-object.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/parsing/parse-object.ts"],"sourcesContent":["import { jsonrepair } from 'jsonrepair';\nimport { z } from 'zod/v4';\n\n/**\n * Error thrown when object parsing fails.\n * Contains the original text for debugging purposes.\n */\nexport class ParseObjectError extends Error {\n    public readonly name = 'ParseObjectError';\n\n    constructor(\n        message: string,\n        public readonly cause?: unknown,\n        public readonly text?: string,\n    ) {\n        super(message);\n    }\n}\n\n/**\n * Parses AI-generated text into structured data validated against a Zod schema.\n *\n * Handles common AI response formats:\n * - JSON wrapped in markdown code blocks\n * - JSON embedded in prose text\n * - Malformed JSON (auto-repaired)\n * - Escaped unicode and special characters\n *\n * @param text - The raw AI response text\n * @param schema - A Zod schema to validate and type the result\n * @returns The parsed and validated data\n * @throws {ParseObjectError} When parsing or validation fails\n *\n * @example\n * ```ts\n * const schema = z.object({ title: z.string(), tags: z.array(z.string()) });\n * const result = parseObject(aiResponse, schema);\n * // result is typed as { title: string; tags: string[] }\n * ```\n */\nexport function parseObject<T>(text: string, schema: z.ZodSchema<T>): T {\n    try {\n        const jsonString = extractJsonString(text);\n        const extracted = extractBySchemaType(jsonString, schema, text);\n        const unescaped = unescapeJsonValues(extracted);\n        return schema.parse(unescaped);\n    } catch (error) {\n        if (error instanceof ParseObjectError) {\n            throw error;\n        }\n        if (error instanceof z.ZodError) {\n            throw new ParseObjectError('Failed to validate response against schema', error, text);\n        }\n        throw error;\n    }\n}\n\nconst MARKDOWN_CODE_BLOCK_RE = /```(?:json)?\\r?\\n([^`]*?)\\r?\\n```/g;\n\nfunction convertToPrimitive(value: unknown, schema: z.ZodType): unknown {\n    if (schema instanceof z.ZodBoolean) return Boolean(value);\n    if (schema instanceof z.ZodNull) return null;\n    if (schema instanceof z.ZodNumber) return Number(value);\n    if (schema instanceof z.ZodString) return String(value);\n    return value;\n}\n\nfunction extractArray(text: string, originalText: string): unknown {\n    const start = text.indexOf('[');\n    const end = text.lastIndexOf(']');\n\n    if (start === -1 || end === -1) {\n        throw new ParseObjectError('No array found in response', undefined, originalText);\n    }\n\n    try {\n        const raw = text.slice(start, end + 1);\n        return JSON.parse(jsonrepair(raw));\n    } catch (error) {\n        throw new ParseObjectError('Failed to parse array JSON', error, originalText);\n    }\n}\n\nfunction extractBySchemaType(text: string, schema: z.ZodType, originalText: string): unknown {\n    if (schema instanceof z.ZodArray) {\n        return extractArray(text, originalText);\n    }\n\n    if (schema instanceof z.ZodObject) {\n        return extractObject(text, originalText);\n    }\n\n    if (\n        schema instanceof z.ZodBoolean ||\n        schema instanceof z.ZodNull ||\n        schema instanceof z.ZodNumber ||\n        schema instanceof z.ZodString\n    ) {\n        return extractPrimitive(text, schema);\n    }\n\n    throw new ParseObjectError('Unsupported schema type', undefined, originalText);\n}\n\nfunction extractJsonFromCodeBlock(block: string): null | string {\n    const content = block.replace(/```(?:json)?\\r?\\n([^`]*?)\\r?\\n```/, '$1').trim();\n    try {\n        JSON.parse(content);\n        return content;\n    } catch {\n        return null;\n    }\n}\n\nfunction extractJsonString(text: string): string {\n    const codeBlocks = text.match(MARKDOWN_CODE_BLOCK_RE);\n    if (codeBlocks && codeBlocks.length > 0) {\n        const validBlocks = codeBlocks\n            .map((block) => extractJsonFromCodeBlock(block))\n            .filter((block): block is string => block !== null);\n\n        if (validBlocks.length > 0) {\n            return findLongestString(validBlocks);\n        }\n    }\n\n    const structures = findJsonStructures(text);\n    if (structures.length > 0) {\n        return findLongestString(structures);\n    }\n\n    return text.replace(/\\s+/g, ' ').trim();\n}\n\nfunction extractObject(text: string, originalText: string): unknown {\n    const start = text.indexOf('{');\n    const end = text.lastIndexOf('}');\n\n    if (start === -1 || end === -1) {\n        throw new ParseObjectError('No object found in response', undefined, originalText);\n    }\n\n    try {\n        const raw = text.slice(start, end + 1);\n        return JSON.parse(jsonrepair(raw));\n    } catch (error) {\n        throw new ParseObjectError('Failed to parse object JSON', error, originalText);\n    }\n}\n\nfunction extractPrimitive(text: string, schema: z.ZodType): unknown {\n    const trimmed = text.trim();\n    try {\n        return convertToPrimitive(JSON.parse(trimmed), schema);\n    } catch {\n        return convertToPrimitive(trimmed, schema);\n    }\n}\n\nfunction findJsonStructures(text: string): string[] {\n    const matches: string[] = [];\n    let depth = 0;\n    let start = -1;\n\n    for (let i = 0; i < text.length; i++) {\n        const char = text[i];\n        if (char === '{' || char === '[') {\n            if (depth === 0) start = i;\n            depth++;\n        } else if (char === '}' || char === ']') {\n            depth--;\n            if (depth === 0 && start !== -1) {\n                const candidate = text.slice(start, i + 1);\n                try {\n                    JSON.parse(candidate);\n                    matches.push(candidate);\n                } catch {\n                    // Invalid JSON, skip\n                }\n            }\n        }\n    }\n\n    return matches;\n}\n\nfunction findLongestString(strings: string[]): string {\n    return strings.reduce((longest, current) =>\n        current.length > longest.length ? current : longest,\n    );\n}\n\nfunction unescapeJsonValues(json: unknown): unknown {\n    if (typeof json === 'string') {\n        return unescapeString(json);\n    }\n    if (Array.isArray(json)) {\n        return json.map(unescapeJsonValues);\n    }\n    if (typeof json === 'object' && json !== null) {\n        return Object.fromEntries(\n            Object.entries(json).map(([key, value]) => [key, unescapeJsonValues(value)]),\n        );\n    }\n    return json;\n}\n\nfunction unescapeString(text: string): string {\n    return text\n        .replace(/\\\\\"/g, '\"')\n        .replace(/\\\\n/g, '\\n')\n        .replace(/\\\\r/g, '\\r')\n        .replace(/\\\\t/g, '\\t')\n        .replace(/\\\\\\\\/g, '\\\\')\n        .replace(/\\\\u([0-9a-fA-F]{4})/g, (_, code) =>\n            String.fromCharCode(Number.parseInt(code, 16)),\n        );\n}\n"],"names":["jsonrepair","z","ParseObjectError","message","cause","text","name","Error","parseObject","schema","jsonString","extractJsonString","extracted","extractBySchemaType","unescaped","unescapeJsonValues","parse","error","ZodError","MARKDOWN_CODE_BLOCK_RE","convertToPrimitive","value","ZodBoolean","Boolean","ZodNull","ZodNumber","Number","ZodString","String","extractArray","originalText","start","indexOf","end","lastIndexOf","undefined","raw","slice","JSON","ZodArray","ZodObject","extractObject","extractPrimitive","extractJsonFromCodeBlock","block","content","replace","trim","codeBlocks","match","length","validBlocks","map","filter","findLongestString","structures","findJsonStructures","trimmed","matches","depth","i","char","candidate","push","strings","reduce","longest","current","json","unescapeString","Array","isArray","Object","fromEntries","entries","key","_","code","fromCharCode","parseInt"],"mappings":"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"}

package/dist/parsing/parse-text.d.ts

@@ -0,0 +1,14 @@
+export interface ParseTextOptions {
+    /** Collapse multiple spaces into one (default: true) */
+    collapseSpaces?: boolean;
+    /** Convert em/en dashes with spaces to commas (default: true) */
+    normalizeEmDashesToCommas?: boolean;
+}
+/**
+ * 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
+ */
+export declare function parseText(text: string, options?: ParseTextOptions): string;

package/dist/parsing/parse-text.js

@@ -0,0 +1,76 @@
+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: '-'
+    }
+];
+/**
+ * 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
+ */ export 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;
+}
+
+//# sourceMappingURL=parse-text.js.map

package/dist/parsing/parse-text.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/parsing/parse-text.ts"],"sourcesContent":["const INVISIBLE_CHARS_RE =\n    /[\\u00AD\\u180E\\u200B-\\u200C\\u200E-\\u200F\\u202A-\\u202E\\u2060-\\u2064\\u2066-\\u2069\\uFEFF]/g;\n\n/* eslint-disable no-control-regex -- intentionally matching control characters */\n// biome-ignore lint/suspicious/noControlCharactersInRegex: intentionally matching control characters for sanitization\nconst ASCII_CTRL_RE = /[\\u0000-\\u0008\\u000B\\u000C\\u000E-\\u001F\\u007F]/g;\n/* eslint-enable no-control-regex */\n\nconst SPACE_LIKE_RE = /[\\u00A0\\u1680\\u2000-\\u200A\\u202F\\u205F\\u3000]/g;\nconst MULTIPLE_SPACES_RE = / {2,}/g;\nconst CR_RE = /\\r\\n?/g;\nconst CITATION_RE = / *\\(oaicite:\\d+\\)\\{index=\\d+\\}/g;\nconst EM_DASH_SEPARATOR_RE = /\\s*[—–―‒]\\s*/g;\n\nconst TYPOGRAPHY_REPLACEMENTS: Array<{ pattern: RegExp; replacement: string }> = [\n    { pattern: /[\\u2018\\u2019\\u201A]/g, replacement: \"'\" },\n    { pattern: /[\\u201C\\u201D\\u201E]/g, replacement: '\"' },\n    { pattern: /\\u2026/g, replacement: '...' },\n    { pattern: /[\\u2022\\u25AA-\\u25AB\\u25B8-\\u25B9\\u25CF]/g, replacement: '-' },\n];\n\nexport interface ParseTextOptions {\n    /** Collapse multiple spaces into one (default: true) */\n    collapseSpaces?: boolean;\n    /** Convert em/en dashes with spaces to commas (default: true) */\n    normalizeEmDashesToCommas?: boolean;\n}\n\n/**\n * Parses and sanitizes text by removing AI artifacts and normalizing typography.\n *\n * @param text - The text to parse\n * @param options - Parsing options\n * @returns The cleaned text\n */\nexport function parseText(text: string, options: ParseTextOptions = {}): string {\n    const { normalizeEmDashesToCommas = true, collapseSpaces = true } = options;\n\n    if (!text) return '';\n\n    let result = text;\n\n    if (result.charCodeAt(0) === 0xfeff) {\n        result = result.slice(1);\n    }\n\n    result = result.replace(CR_RE, '\\n');\n    result = result.replace(CITATION_RE, '');\n    result = result.normalize('NFKC');\n    result = result.replace(INVISIBLE_CHARS_RE, '');\n    result = result.replace(ASCII_CTRL_RE, '');\n\n    if (normalizeEmDashesToCommas) {\n        result = result.replace(EM_DASH_SEPARATOR_RE, ', ');\n    }\n\n    result = result.replace(SPACE_LIKE_RE, ' ');\n\n    for (const { pattern, replacement } of TYPOGRAPHY_REPLACEMENTS) {\n        result = result.replace(pattern, replacement);\n    }\n\n    if (collapseSpaces) {\n        result = result.replace(MULTIPLE_SPACES_RE, ' ').trim();\n    }\n\n    return result;\n}\n"],"names":["INVISIBLE_CHARS_RE","ASCII_CTRL_RE","SPACE_LIKE_RE","MULTIPLE_SPACES_RE","CR_RE","CITATION_RE","EM_DASH_SEPARATOR_RE","TYPOGRAPHY_REPLACEMENTS","pattern","replacement","parseText","text","options","normalizeEmDashesToCommas","collapseSpaces","result","charCodeAt","slice","replace","normalize","trim"],"mappings":"AAAA,IAAMA,qBACF;AAEJ,gFAAgF,GAChF,sHAAsH;AACtH,IAAMC,gBAAgB;AACtB,kCAAkC,GAElC,IAAMC,gBAAgB;AACtB,IAAMC,qBAAqB;AAC3B,IAAMC,QAAQ;AACd,IAAMC,cAAc;AACpB,IAAMC,uBAAuB;AAE7B,IAAMC,0BAA2E;IAC7E;QAAEC,SAAS;QAAyBC,aAAa;IAAI;IACrD;QAAED,SAAS;QAAyBC,aAAa;IAAI;IACrD;QAAED,SAAS;QAAWC,aAAa;IAAM;IACzC;QAAED,SAAS;QAA6CC,aAAa;IAAI;CAC5E;AASD;;;;;;CAMC,GACD,OAAO,SAASC,UAAUC,IAAY;QAAEC,UAAAA,iEAA4B,CAAC;IACjE,yCAAoEA,QAA5DC,2BAAAA,4EAA4B,qEAAgCD,QAA1BE,gBAAAA,sDAAiB;IAE3D,IAAI,CAACH,MAAM,OAAO;IAElB,IAAII,SAASJ;IAEb,IAAII,OAAOC,UAAU,CAAC,OAAO,QAAQ;QACjCD,SAASA,OAAOE,KAAK,CAAC;IAC1B;IAEAF,SAASA,OAAOG,OAAO,CAACd,OAAO;IAC/BW,SAASA,OAAOG,OAAO,CAACb,aAAa;IACrCU,SAASA,OAAOI,SAAS,CAAC;IAC1BJ,SAASA,OAAOG,OAAO,CAAClB,oBAAoB;IAC5Ce,SAASA,OAAOG,OAAO,CAACjB,eAAe;IAEvC,IAAIY,2BAA2B;QAC3BE,SAASA,OAAOG,OAAO,CAACZ,sBAAsB;IAClD;IAEAS,SAASA,OAAOG,OAAO,CAAChB,eAAe;QAElC,kCAAA,2BAAA;;QAAL,QAAK,YAAkCK,4CAAlC,SAAA,6BAAA,QAAA,yBAAA,iCAA2D;YAA3D,kBAAA,aAAQC,sBAAAA,SAASC,0BAAAA;YAClBM,SAASA,OAAOG,OAAO,CAACV,SAASC;QACrC;;QAFK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAIL,IAAIK,gBAAgB;QAChBC,SAASA,OAAOG,OAAO,CAACf,oBAAoB,KAAKiB,IAAI;IACzD;IAEA,OAAOL;AACX"}

package/dist/providers/openrouter.provider.d.ts

@@ -0,0 +1,36 @@
+import type { LanguageModel } from 'ai';
+export interface ModelOptions {
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Reasoning configuration for supported models */
+    reasoning?: {
+        effort?: 'high' | 'low' | 'medium';
+        exclude?: boolean;
+    };
+}
+export interface OpenRouterConfig {
+    apiKey: string;
+    metadata?: OpenRouterMetadata;
+}
+export interface OpenRouterMetadata {
+    /** Application name for X-Title header */
+    application?: string;
+    /** Website URL for HTTP-Referer header */
+    website?: string;
+}
+export interface OpenRouterProvider {
+    /** Get a language model instance */
+    model: (name: string, options?: ModelOptions) => LanguageModel;
+}
+/**
+ * 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!' });
+ * ```
+ */
+export declare function createOpenRouterProvider(config: OpenRouterConfig): OpenRouterProvider;

package/dist/providers/openrouter.provider.js

@@ -0,0 +1,58 @@
+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;
+}
+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;
+}
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+/**
+ * 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!' });
+ * ```
+ */ export function createOpenRouterProvider(config) {
+    var openrouter = 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
+                }
+            }));
+        }
+    };
+}
+
+//# sourceMappingURL=openrouter.provider.js.map

package/dist/providers/openrouter.provider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/providers/openrouter.provider.ts"],"sourcesContent":["import { createOpenRouter } from '@openrouter/ai-sdk-provider';\nimport type { LanguageModel } from 'ai';\n\nexport interface ModelOptions {\n    /** Maximum tokens to generate */\n    maxTokens?: number;\n    /** Reasoning configuration for supported models */\n    reasoning?: {\n        effort?: 'high' | 'low' | 'medium';\n        exclude?: boolean;\n    };\n}\n\nexport interface OpenRouterConfig {\n    apiKey: string;\n    metadata?: OpenRouterMetadata;\n}\n\nexport interface OpenRouterMetadata {\n    /** Application name for X-Title header */\n    application?: string;\n    /** Website URL for HTTP-Referer header */\n    website?: string;\n}\n\nexport interface OpenRouterProvider {\n    /** Get a language model instance */\n    model: (name: string, options?: ModelOptions) => LanguageModel;\n}\n\n/**\n * Creates an OpenRouter provider for AI SDK models.\n *\n * @example\n * ```ts\n * const provider = createOpenRouterProvider({ apiKey: process.env.OPENROUTER_API_KEY });\n * const model = provider.model('anthropic/claude-sonnet-4-20250514');\n *\n * const { text } = await generateText({ model, prompt: 'Hello!' });\n * ```\n */\nexport function createOpenRouterProvider(config: OpenRouterConfig): OpenRouterProvider {\n    const openrouter = createOpenRouter({ apiKey: config.apiKey });\n\n    return {\n        model(name: string, options: ModelOptions = {}): LanguageModel {\n            return openrouter(name, {\n                ...(options.maxTokens !== undefined && {\n                    maxTokens: options.maxTokens,\n                }),\n                ...(options.reasoning && {\n                    extraBody: { reasoning: options.reasoning },\n                }),\n            });\n        },\n    };\n}\n"],"names":["createOpenRouter","createOpenRouterProvider","config","openrouter","apiKey","model","name","options","maxTokens","undefined","reasoning","extraBody"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAASA,gBAAgB,QAAQ,8BAA8B;AA8B/D;;;;;;;;;;CAUC,GACD,OAAO,SAASC,yBAAyBC,MAAwB;IAC7D,IAAMC,aAAaH,iBAAiB;QAAEI,QAAQF,OAAOE,MAAM;IAAC;IAE5D,OAAO;QACHC,OAAAA,SAAAA,MAAMC,IAAY;gBAAEC,UAAAA,iEAAwB,CAAC;YACzC,OAAOJ,WAAWG,MAAM,mBAChBC,QAAQC,SAAS,KAAKC,aAAa;gBACnCD,WAAWD,QAAQC,SAAS;YAChC,GACID,QAAQG,SAAS,IAAI;gBACrBC,WAAW;oBAAED,WAAWH,QAAQG,SAAS;gBAAC;YAC9C;QAER;IACJ;AACJ"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jterrazz/intelligence",
   "author": "Jean-Baptiste Terrazzoni <contact@jterrazz.com>",
-  "version": "2.0.0",
+  "version": "3.0.1",
   "exports": {
     ".": {
       "require": "./dist/index.cjs",
@@ -14,24 +14,23 @@
   "type": "module",
   "scripts": {
     "build": "ts-build",
-    "test": "vitest",
-    "lint": "quality",
-    "lint:fix": "quality-fix"
+    "lint": "ts-check",
+    "lint:fix": "ts-fix",
+    "test": "vitest"
   },
   "devDependencies": {
-    "@jterrazz/quality": "^3.0.3",
-    "@jterrazz/test": "^3.0.0",
-    "@jterrazz/typescript": "^3.0.0"
+    "@jterrazz/quality": "^5.0.1",
+    "@jterrazz/test": "^3.1.0",
+    "@jterrazz/typescript": "^3.1.0"
+  },
+  "peerDependencies": {
+    "ai": ">=5.0.0",
+    "zod": ">=4.0.0"
   },
   "dependencies": {
-    "@jterrazz/logger": "^1.4.2",
-    "@langchain/community": "^0.3.49",
-    "@langchain/core": "^0.3.66",
-    "@langchain/openai": "^0.5.15",
-    "@openrouter/ai-sdk-provider": "^0.7.3",
-    "ai": "^4.3.16",
-    "jsonrepair": "^3.13.0",
-    "zod": "^3.25.67"
+    "@jterrazz/logger": "^1.5.0",
+    "@openrouter/ai-sdk-provider": "^1.4.0",
+    "jsonrepair": "^3.13.1"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

package/dist/adapters/agents/chat-agent.adapter.d.ts

@@ -1,27 +0,0 @@
-import { type LoggerPort } from '@jterrazz/logger';
-import { z } from 'zod/v4';
-import { type AgentPort } from '../../ports/agent.port.js';
-import type { ModelPort } from '../../ports/model.port.js';
-import type { PromptPort } from '../../ports/prompt.port.js';
-import type { SystemPrompt } from '../prompts/system-prompt.adapter.js';
-export interface ChatAgentOptions<TOutput = string> {
-    logger?: LoggerPort;
-    model: ModelPort;
-    schema?: z.ZodSchema<TOutput>;
-    systemPrompt: SystemPrompt;
-    verbose?: boolean;
-}
-/**
- * A conversational agent for direct, one-shot interactions with a model.
- * It supports optional response parsing against a Zod schema but does not use tools.
- * @template TOutput - The TypeScript type of the output
- */
-export declare class ChatAgent<TOutput = string> implements AgentPort<PromptPort, TOutput> {
-    readonly name: string;
-    private readonly options;
-    constructor(name: string, options: ChatAgentOptions<TOutput>);
-    run(input?: PromptPort): Promise<null | TOutput>;
-    private invokeModel;
-    private parseResponse;
-    private resolveUserInput;
-}

package/dist/adapters/agents/chat-agent.adapter.js

@@ -1,356 +0,0 @@
-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 _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-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;
-}
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
-    }
-}
-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
-        };
-    }
-}
-import { generateText } from 'ai';
-import { z } from 'zod/v4';
-import { StructuredResponseParser } from '../utils/structured-response-parser.js';
-/**
- * A conversational agent for direct, one-shot interactions with a model.
- * It supports optional response parsing against a Zod schema but does not use tools.
- * @template TOutput - The TypeScript type of the output
- */ export var ChatAgent = /*#__PURE__*/ function() {
-    "use strict";
-    function ChatAgent(name, options) {
-        _class_call_check(this, ChatAgent);
-        _define_property(this, "name", void 0);
-        _define_property(this, "options", void 0);
-        this.name = name;
-        this.options = options;
-    }
-    _create_class(ChatAgent, [
-        {
-            key: "run",
-            value: function run(input) {
-                return _async_to_generator(function() {
-                    var _this_options_logger, content, _this_options_logger1, parsedResponse, _this_options_logger2, error, _this_options_logger3;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.debug('Starting query execution', {
-                                    agent: this.name
-                                });
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    3,
-                                    ,
-                                    4
-                                ]);
-                                return [
-                                    4,
-                                    this.invokeModel(input)
-                                ];
-                            case 2:
-                                content = _state.sent();
-                                if (this.options.schema) {
-                                    ;
-                                    parsedResponse = this.parseResponse(content, this.options.schema);
-                                    (_this_options_logger1 = this.options.logger) === null || _this_options_logger1 === void 0 ? void 0 : _this_options_logger1.debug('Execution finished and response parsed', {
-                                        agent: this.name
-                                    });
-                                    return [
-                                        2,
-                                        parsedResponse
-                                    ];
-                                } else {
-                                    ;
-                                    (_this_options_logger2 = this.options.logger) === null || _this_options_logger2 === void 0 ? void 0 : _this_options_logger2.debug('Execution finished', {
-                                        agent: this.name
-                                    });
-                                    return [
-                                        2,
-                                        content
-                                    ];
-                                }
-                                return [
-                                    3,
-                                    4
-                                ];
-                            case 3:
-                                error = _state.sent();
-                                (_this_options_logger3 = this.options.logger) === null || _this_options_logger3 === void 0 ? void 0 : _this_options_logger3.error('Execution failed', {
-                                    agent: this.name,
-                                    error: _instanceof(error, Error) ? error.message : 'Unknown error',
-                                    errorStack: _instanceof(error, Error) ? error.stack : undefined
-                                });
-                                return [
-                                    2,
-                                    null
-                                ];
-                            case 4:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                }).call(this);
-            }
-        },
-        {
-            key: "invokeModel",
-            value: function invokeModel(input) {
-                return _async_to_generator(function() {
-                    var _this_options_logger, userInput, systemMessage, jsonSchema, isPrimitiveType, messages, _this_options_logger1, generateConfig, jsonSchema1, text;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                userInput = this.resolveUserInput(input);
-                                systemMessage = this.options.systemPrompt.generate();
-                                if (this.options.schema) {
-                                    jsonSchema = z.toJSONSchema(this.options.schema);
-                                    isPrimitiveType = [
-                                        'boolean',
-                                        'integer',
-                                        'number',
-                                        'string'
-                                    ].includes(jsonSchema.type);
-                                    if (isPrimitiveType) {
-                                        systemMessage += "\n\n<OUTPUT_FORMAT>\nYou must respond with a ".concat(jsonSchema.type, " value that matches this schema:\n\n```json\n").concat(JSON.stringify(jsonSchema, null, 2), "\n```\n\nYour response should be only the ").concat(jsonSchema.type, " value, without any JSON wrapping or additional text.\n</OUTPUT_FORMAT>");
-                                    } else {
-                                        systemMessage += "\n\n<OUTPUT_FORMAT>\nYou must respond with valid JSON that matches this JSON schema description:\n\n```json\n".concat(JSON.stringify(jsonSchema, null, 2), "\n```\n\nYour response must be parseable JSON that validates against this schema. Do not include any text outside the JSON.\n</OUTPUT_FORMAT>");
-                                    }
-                                }
-                                messages = [
-                                    {
-                                        content: systemMessage,
-                                        role: 'system'
-                                    },
-                                    {
-                                        content: userInput,
-                                        role: 'user'
-                                    }
-                                ];
-                                (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.debug('Invoking model...', {
-                                    agent: this.name,
-                                    hasSchema: !!this.options.schema
-                                });
-                                if (this.options.verbose) {
-                                    ;
-                                    (_this_options_logger1 = this.options.logger) === null || _this_options_logger1 === void 0 ? void 0 : _this_options_logger1.debug('Sending messages to model...', {
-                                        agent: this.name,
-                                        messages: messages
-                                    });
-                                }
-                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                generateConfig = {
-                                    messages: messages,
-                                    model: this.options.model.getVercelModel()
-                                };
-                                // Prepare structured outputs configuration for better schema validation when schema is provided
-                                // NOTE: OpenRouter supports structured outputs, but @openrouter/ai-sdk-provider (v0.7.3)
-                                // doesn't pass through responseFormat parameter yet. Currently relies on prompt-based instructions.
-                                // Once provider support is added, this will provide stronger guarantees than prompts alone.
-                                // See: https://openrouter.ai/docs/features/structured-outputs
-                                if (this.options.schema) {
-                                    jsonSchema1 = z.toJSONSchema(this.options.schema);
-                                    generateConfig.responseFormat = {
-                                        json_schema: {
-                                            name: 'response',
-                                            schema: jsonSchema1,
-                                            strict: true
-                                        },
-                                        type: 'json_schema'
-                                    };
-                                }
-                                return [
-                                    4,
-                                    generateText(generateConfig)
-                                ];
-                            case 1:
-                                text = _state.sent().text;
-                                return [
-                                    2,
-                                    text
-                                ];
-                        }
-                    });
-                }).call(this);
-            }
-        },
-        {
-            key: "parseResponse",
-            value: function parseResponse(content, schema) {
-                try {
-                    return new StructuredResponseParser(schema).parse(content);
-                } catch (error) {
-                    var _this_options_logger;
-                    (_this_options_logger = this.options.logger) === null || _this_options_logger === void 0 ? void 0 : _this_options_logger.error('Failed to parse model response.', {
-                        agent: this.name,
-                        error: _instanceof(error, Error) ? error.message : 'Unknown error',
-                        rawContent: content
-                    });
-                    throw new Error('Invalid response format from model.');
-                }
-            }
-        },
-        {
-            key: "resolveUserInput",
-            value: function resolveUserInput(input) {
-                if (input) {
-                    return input.generate();
-                }
-                return 'Proceed with your instructions.';
-            }
-        }
-    ]);
-    return ChatAgent;
-}();
-
-//# sourceMappingURL=chat-agent.adapter.js.map