@jterrazz/intelligence 2.0.0 → 3.0.0

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,80 @@
+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*|\s*[—–―‒]\s+)/g;
+var TYPOGRAPHY_REPLACEMENTS = [
+    {
+        pattern: /[\u2018\u2019\u201A]/g,
+        replacement: "'"
+    },
+    {
+        pattern: /[\u201C\u201D\u201E]/g,
+        replacement: '"'
+    },
+    {
+        pattern: /[\u2013\u2014]/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*|\\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: /[\\u2013\\u2014]/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;QAAmBC,aAAa;IAAI;IAC/C;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.0",
   "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;
-}