@jterrazz/intelligence 1.6.1 → 3.0.0

package/dist/adapters/utils/ai-response-parser-error.js

@@ -1,136 +0,0 @@
-/**
- * Custom error for AI response parsing failures
- */ 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(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 _is_native_function(fn) {
-    return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-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 _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-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);
-}
-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;
-    })();
-}
-export var AIResponseParserError = /*#__PURE__*/ function(Error1) {
-    "use strict";
-    _inherits(AIResponseParserError, Error1);
-    function AIResponseParserError(message, cause, text) {
-        _class_call_check(this, AIResponseParserError);
-        var _this;
-        _this = _call_super(this, AIResponseParserError, [
-            message
-        ]), _define_property(_this, "cause", void 0), _define_property(_this, "text", void 0), _this.cause = cause, _this.text = text;
-        _this.name = 'AIResponseParserError';
-        return _this;
-    }
-    return AIResponseParserError;
-}(_wrap_native_super(Error));
-
-//# sourceMappingURL=ai-response-parser-error.js.map

package/dist/adapters/utils/ai-response-parser-error.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapters/utils/ai-response-parser-error.ts"],"sourcesContent":["/**\n * Custom error for AI response parsing failures\n */\nexport class AIResponseParserError extends Error {\n    constructor(\n        message: string,\n        public readonly cause?: unknown,\n        public readonly text?: string,\n    ) {\n        super(message);\n        this.name = 'AIResponseParserError';\n    }\n}\n"],"names":["AIResponseParserError","message","cause","text","name","Error"],"mappings":"AAAA;;CAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACD,OAAO,IAAA,AAAMA,sCAAN;;cAAMA;aAAAA,sBAELC,OAAe,EACf,AAAgBC,KAAe,EAC/B,AAAgBC,IAAa;gCAJxBH;;gBAML,kBANKA;YAMCC;qGAHUC,QAAAA,aACAC,OAAAA;QAGhB,MAAKC,IAAI,GAAG;;;WAPPJ;qBAA8BK,QAS1C"}

package/dist/adapters/utils/ai-response-parser.d.ts

@@ -1,60 +0,0 @@
-import { z } from 'zod/v4';
-/**
- * Parses AI response text into structured data based on Zod schema
- */
-export declare class AIResponseParser<T> {
-    private readonly schema;
-    constructor(schema: z.ZodSchema<T>);
-    /**
-     * Parses the AI response text based on the configured schema
-     */
-    parse(text: string): T;
-    /**
-     * Cleans text and finds the largest schema-compatible structure
-     */
-    private cleanText;
-    /**
-     * Converts value to appropriate primitive type based on schema
-     */
-    private convertToPrimitive;
-    /**
-     * Extracts array from text
-     */
-    private extractArray;
-    /**
-     * Extracts and validates JSON content from a code block
-     */
-    private extractJsonFromCodeBlock;
-    /**
-     * Extracts and parses JSON from text based on schema type
-     */
-    private extractJsonFromText;
-    /**
-     * Extracts object from text
-     */
-    private extractObject;
-    /**
-     * Extracts and converts primitive value from text
-     */
-    private extractPrimitive;
-    /**
-     * Finds valid JSON structures in raw text
-     */
-    private findJsonStructures;
-    /**
-     * Returns the largest string from an array of strings
-     */
-    private findLargestString;
-    /**
-     * Repairs common JSON issues using jsonrepair library
-     */
-    private repairJson;
-    /**
-     * Recursively unescapes all string values in a JSON object/array
-     */
-    private unescapeJsonValues;
-    /**
-     * Unescapes common escaped characters in text
-     */
-    private unescapeText;
-}

package/dist/adapters/utils/ai-response-parser.js

@@ -1,347 +0,0 @@
-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 _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 _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 _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();
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-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);
-}
-import { jsonrepair } from 'jsonrepair';
-import { z } from 'zod/v4';
-import { AIResponseParserError } from './ai-response-parser-error.js';
-/**
- * Parses AI response text into structured data based on Zod schema
- */ export var AIResponseParser = /*#__PURE__*/ function() {
-    "use strict";
-    function AIResponseParser(schema) {
-        _class_call_check(this, AIResponseParser);
-        _define_property(this, "schema", void 0);
-        this.schema = schema;
-    }
-    _create_class(AIResponseParser, [
-        {
-            key: "parse",
-            value: /**
-     * Parses the AI response text based on the configured schema
-     */ function parse(text) {
-                try {
-                    var cleanedText = this.cleanText(text);
-                    var json = this.extractJsonFromText(cleanedText);
-                    var unescapedJson = this.unescapeJsonValues(json);
-                    return this.schema.parse(unescapedJson);
-                } catch (error) {
-                    if (_instanceof(error, z.ZodError)) {
-                        throw new AIResponseParserError('Failed to validate response against schema', error, text);
-                    }
-                    throw error;
-                }
-            }
-        },
-        {
-            key: "cleanText",
-            value: /**
-     * Cleans text and finds the largest schema-compatible structure
-     */ function cleanText(text) {
-                var _this = this;
-                // First try to extract from markdown code blocks
-                var codeBlocks = text.match(/```(?:json)?\r?\n([^`]*?)\r?\n```/g);
-                if (codeBlocks) {
-                    // Try each code block and return the largest valid one
-                    var validBlocks = codeBlocks.map(function(block) {
-                        return _this.extractJsonFromCodeBlock(block);
-                    }).filter(function(block) {
-                        return block !== null;
-                    });
-                    if (validBlocks.length > 0) {
-                        return this.findLargestString(validBlocks);
-                    }
-                }
-                // If no valid code blocks, try to find JSON-like structures in the text
-                var jsonMatches = this.findJsonStructures(text);
-                if (jsonMatches.length > 0) {
-                    return this.findLargestString(jsonMatches);
-                }
-                // If no JSON structures found, clean and return the original text
-                return text.replace(/\s+/g, ' ').trim();
-            }
-        },
-        {
-            key: "convertToPrimitive",
-            value: /**
-     * Converts value to appropriate primitive type based on schema
-     */ function convertToPrimitive(value, schema) {
-                if (_instanceof(schema, z.ZodString)) {
-                    return String(value);
-                }
-                if (_instanceof(schema, z.ZodNumber)) {
-                    return Number(value);
-                }
-                if (_instanceof(schema, z.ZodBoolean)) {
-                    return Boolean(value);
-                }
-                if (_instanceof(schema, z.ZodNull)) {
-                    return null;
-                }
-                return value;
-            }
-        },
-        {
-            key: "extractArray",
-            value: /**
-     * Extracts array from text
-     */ function extractArray(text) {
-                var arrayStart = text.indexOf('[');
-                var arrayEnd = text.lastIndexOf(']');
-                if (arrayStart === -1 || arrayEnd === -1) {
-                    throw new AIResponseParserError('No array found in response', undefined, text);
-                }
-                try {
-                    var raw = text.slice(arrayStart, arrayEnd + 1);
-                    var repaired = this.repairJson(raw);
-                    return JSON.parse(repaired);
-                } catch (error) {
-                    throw new AIResponseParserError('Failed to parse array JSON', error, text);
-                }
-            }
-        },
-        {
-            key: "extractJsonFromCodeBlock",
-            value: /**
-     * Extracts and validates JSON content from a code block
-     */ function extractJsonFromCodeBlock(block) {
-                var content = block.replace(/```(?:json)?\r?\n([^`]*?)\r?\n```/, '$1').trim();
-                try {
-                    // Attempt to parse as JSON to validate structure
-                    JSON.parse(content);
-                    return content;
-                } catch (e) {
-                    return null;
-                }
-            }
-        },
-        {
-            key: "extractJsonFromText",
-            value: /**
-     * Extracts and parses JSON from text based on schema type
-     */ function extractJsonFromText(text) {
-                if (_instanceof(this.schema, z.ZodArray)) {
-                    return this.extractArray(text);
-                }
-                if (_instanceof(this.schema, z.ZodObject)) {
-                    return this.extractObject(text);
-                }
-                if (_instanceof(this.schema, z.ZodString) || _instanceof(this.schema, z.ZodNumber) || _instanceof(this.schema, z.ZodBoolean) || _instanceof(this.schema, z.ZodNull)) {
-                    return this.extractPrimitive(text, this.schema);
-                }
-                throw new AIResponseParserError('Unsupported schema type', undefined, text);
-            }
-        },
-        {
-            key: "extractObject",
-            value: /**
-     * Extracts object from text
-     */ function extractObject(text) {
-                var objectStart = text.indexOf('{');
-                var objectEnd = text.lastIndexOf('}');
-                if (objectStart === -1 || objectEnd === -1) {
-                    throw new AIResponseParserError('No object found in response', undefined, text);
-                }
-                try {
-                    var raw = text.slice(objectStart, objectEnd + 1);
-                    var repaired = this.repairJson(raw);
-                    return JSON.parse(repaired);
-                } catch (error) {
-                    throw new AIResponseParserError('Failed to parse object JSON', error, text);
-                }
-            }
-        },
-        {
-            key: "extractPrimitive",
-            value: /**
-     * Extracts and converts primitive value from text
-     */ function extractPrimitive(text, schema) {
-                var trimmed = text.trim();
-                // Try to parse as JSON first in case it's quoted
-                try {
-                    var parsed = JSON.parse(trimmed);
-                    return this.convertToPrimitive(parsed, schema);
-                } catch (e) {
-                    // If not valid JSON, use the raw string
-                    return this.convertToPrimitive(trimmed, schema);
-                }
-            }
-        },
-        {
-            key: "findJsonStructures",
-            value: /**
-     * Finds valid JSON structures in raw text
-     */ function findJsonStructures(text) {
-                var jsonMatches = [];
-                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 potentialJson = text.slice(start, i + 1);
-                            try {
-                                JSON.parse(potentialJson);
-                                jsonMatches.push(potentialJson);
-                            } catch (e) {
-                            // Invalid JSON, ignore
-                            }
-                        }
-                    }
-                }
-                return jsonMatches;
-            }
-        },
-        {
-            key: "findLargestString",
-            value: /**
-     * Returns the largest string from an array of strings
-     */ function findLargestString(strings) {
-                return strings.reduce(function(largest, current) {
-                    return current.length > largest.length ? current : largest;
-                }, strings[0]);
-            }
-        },
-        {
-            key: "repairJson",
-            value: /**
-     * Repairs common JSON issues using jsonrepair library
-     */ function repairJson(jsonString) {
-                return jsonrepair(jsonString);
-            }
-        },
-        {
-            key: "unescapeJsonValues",
-            value: /**
-     * Recursively unescapes all string values in a JSON object/array
-     */ function unescapeJsonValues(json) {
-                var _this = this;
-                if (typeof json === 'string') {
-                    return this.unescapeText(json);
-                }
-                if (Array.isArray(json)) {
-                    return json.map(function(item) {
-                        return _this.unescapeJsonValues(item);
-                    });
-                }
-                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,
-                            _this.unescapeJsonValues(value)
-                        ];
-                    }));
-                }
-                return json;
-            }
-        },
-        {
-            key: "unescapeText",
-            value: /**
-     * Unescapes common escaped characters in text
-     */ function unescapeText(text) {
-                return text.replace(/\\"/g, '"') // Unescape quotes
-                .replace(/\\n/g, '\n') // Unescape newlines
-                .replace(/\\r/g, '\r') // Unescape carriage returns
-                .replace(/\\t/g, '\t') // Unescape tabs
-                .replace(/\\\\/g, '\\') // Unescape backslashes
-                .replace(/\\u([0-9a-fA-F]{4})/g, function(_, code) {
-                    return String.fromCharCode(parseInt(code, 16));
-                }); // Unescape unicode
-            }
-        }
-    ]);
-    return AIResponseParser;
-}();
-
-//# sourceMappingURL=ai-response-parser.js.map

package/dist/adapters/utils/ai-response-parser.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapters/utils/ai-response-parser.ts"],"sourcesContent":["import { jsonrepair } from 'jsonrepair';\nimport { z } from 'zod/v4';\n\nimport { AIResponseParserError } from './ai-response-parser-error.js';\n\n/**\n * Parses AI response text into structured data based on Zod schema\n */\nexport class AIResponseParser<T> {\n    constructor(private readonly schema: z.ZodSchema<T>) {}\n\n    /**\n     * Parses the AI response text based on the configured schema\n     */\n    public parse(text: string): T {\n        try {\n            const cleanedText = this.cleanText(text);\n            const json = this.extractJsonFromText(cleanedText);\n            const unescapedJson = this.unescapeJsonValues(json);\n            return this.schema.parse(unescapedJson);\n        } catch (error) {\n            if (error instanceof z.ZodError) {\n                throw new AIResponseParserError(\n                    'Failed to validate response against schema',\n                    error,\n                    text,\n                );\n            }\n            throw error;\n        }\n    }\n\n    /**\n     * Cleans text and finds the largest schema-compatible structure\n     */\n    private cleanText(text: string): string {\n        // First try to extract from markdown code blocks\n        const codeBlocks = text.match(/```(?:json)?\\r?\\n([^`]*?)\\r?\\n```/g);\n        if (codeBlocks) {\n            // Try each code block and return the largest valid one\n            const validBlocks = codeBlocks\n                .map((block) => this.extractJsonFromCodeBlock(block))\n                .filter((block): block is string => block !== null);\n\n            if (validBlocks.length > 0) {\n                return this.findLargestString(validBlocks);\n            }\n        }\n\n        // If no valid code blocks, try to find JSON-like structures in the text\n        const jsonMatches = this.findJsonStructures(text);\n        if (jsonMatches.length > 0) {\n            return this.findLargestString(jsonMatches);\n        }\n\n        // If no JSON structures found, clean and return the original text\n        return text.replace(/\\s+/g, ' ').trim();\n    }\n\n    /**\n     * Converts value to appropriate primitive type based on schema\n     */\n    private convertToPrimitive(value: unknown, schema: z.ZodType): unknown {\n        if (schema instanceof z.ZodString) {\n            return String(value);\n        }\n        if (schema instanceof z.ZodNumber) {\n            return Number(value);\n        }\n        if (schema instanceof z.ZodBoolean) {\n            return Boolean(value);\n        }\n        if (schema instanceof z.ZodNull) {\n            return null;\n        }\n        return value;\n    }\n\n    /**\n     * Extracts array from text\n     */\n    private extractArray(text: string): unknown {\n        const arrayStart = text.indexOf('[');\n        const arrayEnd = text.lastIndexOf(']');\n        if (arrayStart === -1 || arrayEnd === -1) {\n            throw new AIResponseParserError('No array found in response', undefined, text);\n        }\n        try {\n            const raw = text.slice(arrayStart, arrayEnd + 1);\n            const repaired = this.repairJson(raw);\n            return JSON.parse(repaired);\n        } catch (error) {\n            throw new AIResponseParserError('Failed to parse array JSON', error, text);\n        }\n    }\n\n    /**\n     * Extracts and validates JSON content from a code block\n     */\n    private extractJsonFromCodeBlock(block: string): null | string {\n        const content = block.replace(/```(?:json)?\\r?\\n([^`]*?)\\r?\\n```/, '$1').trim();\n        try {\n            // Attempt to parse as JSON to validate structure\n            JSON.parse(content);\n            return content;\n        } catch {\n            return null;\n        }\n    }\n\n    /**\n     * Extracts and parses JSON from text based on schema type\n     */\n    private extractJsonFromText(text: string): unknown {\n        if (this.schema instanceof z.ZodArray) {\n            return this.extractArray(text);\n        }\n\n        if (this.schema instanceof z.ZodObject) {\n            return this.extractObject(text);\n        }\n\n        if (\n            this.schema instanceof z.ZodString ||\n            this.schema instanceof z.ZodNumber ||\n            this.schema instanceof z.ZodBoolean ||\n            this.schema instanceof z.ZodNull\n        ) {\n            return this.extractPrimitive(text, this.schema);\n        }\n\n        throw new AIResponseParserError('Unsupported schema type', undefined, text);\n    }\n\n    /**\n     * Extracts object from text\n     */\n    private extractObject(text: string): unknown {\n        const objectStart = text.indexOf('{');\n        const objectEnd = text.lastIndexOf('}');\n        if (objectStart === -1 || objectEnd === -1) {\n            throw new AIResponseParserError('No object found in response', undefined, text);\n        }\n        try {\n            const raw = text.slice(objectStart, objectEnd + 1);\n            const repaired = this.repairJson(raw);\n            return JSON.parse(repaired);\n        } catch (error) {\n            throw new AIResponseParserError('Failed to parse object JSON', error, text);\n        }\n    }\n\n    /**\n     * Extracts and converts primitive value from text\n     */\n    private extractPrimitive(text: string, schema: z.ZodType): unknown {\n        const trimmed = text.trim();\n\n        // Try to parse as JSON first in case it's quoted\n        try {\n            const parsed = JSON.parse(trimmed);\n            return this.convertToPrimitive(parsed, schema);\n        } catch {\n            // If not valid JSON, use the raw string\n            return this.convertToPrimitive(trimmed, schema);\n        }\n    }\n\n    /**\n     * Finds valid JSON structures in raw text\n     */\n    private findJsonStructures(text: string): string[] {\n        const jsonMatches: 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 potentialJson = text.slice(start, i + 1);\n                    try {\n                        JSON.parse(potentialJson);\n                        jsonMatches.push(potentialJson);\n                    } catch {\n                        // Invalid JSON, ignore\n                    }\n                }\n            }\n        }\n\n        return jsonMatches;\n    }\n\n    /**\n     * Returns the largest string from an array of strings\n     */\n    private findLargestString(strings: string[]): string {\n        return strings.reduce(\n            (largest, current) => (current.length > largest.length ? current : largest),\n            strings[0],\n        );\n    }\n\n    /**\n     * Repairs common JSON issues using jsonrepair library\n     */\n    private repairJson(jsonString: string): string {\n        return jsonrepair(jsonString);\n    }\n\n    /**\n     * Recursively unescapes all string values in a JSON object/array\n     */\n    private unescapeJsonValues(json: unknown): unknown {\n        if (typeof json === 'string') {\n            return this.unescapeText(json);\n        }\n        if (Array.isArray(json)) {\n            return json.map((item) => this.unescapeJsonValues(item));\n        }\n        if (typeof json === 'object' && json !== null) {\n            return Object.fromEntries(\n                Object.entries(json).map(([key, value]) => [key, this.unescapeJsonValues(value)]),\n            );\n        }\n        return json;\n    }\n\n    /**\n     * Unescapes common escaped characters in text\n     */\n    private unescapeText(text: string): string {\n        return text\n            .replace(/\\\\\"/g, '\"') // Unescape quotes\n            .replace(/\\\\n/g, '\\n') // Unescape newlines\n            .replace(/\\\\r/g, '\\r') // Unescape carriage returns\n            .replace(/\\\\t/g, '\\t') // Unescape tabs\n            .replace(/\\\\\\\\/g, '\\\\') // Unescape backslashes\n            .replace(/\\\\u([0-9a-fA-F]{4})/g, (_, code) => String.fromCharCode(parseInt(code, 16))); // Unescape unicode\n    }\n}\n"],"names":["jsonrepair","z","AIResponseParserError","AIResponseParser","schema","parse","text","cleanedText","cleanText","json","extractJsonFromText","unescapedJson","unescapeJsonValues","error","ZodError","codeBlocks","match","validBlocks","map","block","extractJsonFromCodeBlock","filter","length","findLargestString","jsonMatches","findJsonStructures","replace","trim","convertToPrimitive","value","ZodString","String","ZodNumber","Number","ZodBoolean","Boolean","ZodNull","extractArray","arrayStart","indexOf","arrayEnd","lastIndexOf","undefined","raw","slice","repaired","repairJson","JSON","content","ZodArray","ZodObject","extractObject","extractPrimitive","objectStart","objectEnd","trimmed","parsed","depth","start","i","char","potentialJson","push","strings","reduce","largest","current","jsonString","unescapeText","Array","isArray","item","Object","fromEntries","entries","key","_","code","fromCharCode","parseInt"],"mappings":"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"}

package/dist/ports/agent.port.d.ts

@@ -1,17 +0,0 @@
-import type { PromptPort } from './prompt.port.js';
-/**
- * Port for chat agents with generic input and output types
- * @template TInput - The type of input parameters the agent accepts
- * @template TOutput - The type of output the agent returns
- */
-export interface AgentPort<TInput = PromptPort, TOutput = string> {
-    /**
-     * A descriptive name for the agent, used for logging and identification.
-     */
-    readonly name: string;
-    /**
-     * Run the agent with optional input and return optional response
-     * @param input - The input to process
-     */
-    run(input?: TInput): Promise<null | TOutput>;
-}

package/dist/ports/agent.port.js

@@ -1,7 +0,0 @@
-/**
- * Port for chat agents with generic input and output types
- * @template TInput - The type of input parameters the agent accepts
- * @template TOutput - The type of output the agent returns
- */ export { };
-
-//# sourceMappingURL=agent.port.js.map

package/dist/ports/agent.port.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/ports/agent.port.ts"],"sourcesContent":["import type { PromptPort } from './prompt.port.js';\n\n/**\n * Port for chat agents with generic input and output types\n * @template TInput - The type of input parameters the agent accepts\n * @template TOutput - The type of output the agent returns\n */\nexport interface AgentPort<TInput = PromptPort, TOutput = string> {\n    /**\n     * A descriptive name for the agent, used for logging and identification.\n     */\n    readonly name: string;\n\n    /**\n     * Run the agent with optional input and return optional response\n     * @param input - The input to process\n     */\n    run(input?: TInput): Promise<null | TOutput>;\n}\n"],"names":[],"mappings":"AAEA;;;;CAIC,GACD,WAWC"}

package/dist/ports/model.port.d.ts

@@ -1,10 +0,0 @@
-import type { BaseLanguageModel } from '@langchain/core/language_models/base';
-/**
- * Port for models
- */
-export interface ModelPort {
-    /**
-     * Get the configured language model instance
-     */
-    getModel(): BaseLanguageModel;
-}

package/dist/ports/model.port.js

@@ -1,5 +0,0 @@
-/**
- * Port for models
- */ export { };
-
-//# sourceMappingURL=model.port.js.map

package/dist/ports/model.port.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/ports/model.port.ts"],"sourcesContent":["import type { BaseLanguageModel } from '@langchain/core/language_models/base';\n\n/**\n * Port for models\n */\nexport interface ModelPort {\n    /**\n     * Get the configured language model instance\n     */\n    getModel(): BaseLanguageModel;\n}\n"],"names":[],"mappings":"AAEA;;CAEC,GACD,WAKC"}

package/dist/ports/prompt.port.d.ts

@@ -1,9 +0,0 @@
-/**
- * Port for prompt generation
- */
-export interface PromptPort {
-    /**
-     * Generate the prompt text
-     */
-    generate(): string;
-}

package/dist/ports/prompt.port.js

@@ -1,5 +0,0 @@
-/**
- * Port for prompt generation
- */ export { };
-
-//# sourceMappingURL=prompt.port.js.map

package/dist/ports/prompt.port.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/ports/prompt.port.ts"],"sourcesContent":["/**\n * Port for prompt generation\n */\nexport interface PromptPort {\n    /**\n     * Generate the prompt text\n     */\n    generate(): string;\n}\n"],"names":[],"mappings":"AAAA;;CAEC,GACD,WAKC"}

package/dist/ports/tool.port.d.ts

@@ -1,11 +0,0 @@
-import type { DynamicStructuredTool, DynamicTool } from 'langchain/tools';
-import type { z } from 'zod/v4';
-/**
- * Port for tools
- */
-export interface ToolPort {
-    /**
-     * Get the underlying LangChain tool instance
-     */
-    getDynamicTool(): DynamicStructuredTool<z.ZodSchema<unknown>> | DynamicTool;
-}