@jterrazz/intelligence 1.0.0

package/dist/adapters/tools/safe-tool.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/tools/safe-tool.adapter.ts"],"sourcesContent":["import type { LoggerPort } from '@jterrazz/logger';\nimport { DynamicStructuredTool, DynamicTool } from 'langchain/tools';\nimport type { z } from 'zod/v4';\n\nimport type { Tool } from '../../ports/tool.port.js';\n\nexport interface SafeToolOptions<T> {\n    logger?: LoggerPort;\n    schema?: z.ZodSchema<T>;\n}\n\nexport type ToolConfig<T = void> = {\n    description: string;\n    execute: ToolFunction<T>;\n    name: string;\n};\n\nexport type ToolFunction<T = void> = T extends void\n    ? () => Promise<string>\n    : (args: T) => Promise<string>;\n\n/**\n * Safe tool adapter that provides error handling and logging for LangChain tools\n */\nexport class SafeToolAdapter<T = void> implements Tool {\n    private readonly dynamicTool: DynamicStructuredTool<z.ZodSchema<T>> | DynamicTool;\n\n    constructor(\n        private readonly config: ToolConfig<T>,\n        private readonly options: SafeToolOptions<T> = {},\n    ) {\n        const { logger, schema } = options;\n\n        if (schema) {\n            // Use DynamicStructuredTool for parameterized tools\n            this.dynamicTool = new DynamicStructuredTool({\n                description: config.description,\n                func: async (args: T) => {\n                    try {\n                        return await (config.execute as ToolFunction<T>)(args);\n                    } catch (error) {\n                        const errorMessage = error instanceof Error ? error.message : String(error);\n\n                        logger?.error(`Unexpected error in ${config.name}`, {\n                            args,\n                            error: errorMessage,\n                            toolName: config.name,\n                        });\n\n                        return `Tool ${config.name} failed to execute`;\n                    }\n                },\n                name: config.name,\n                schema: schema,\n            });\n        } else {\n            // Use DynamicTool for simple tools\n            this.dynamicTool = new DynamicTool({\n                description: config.description,\n                func: async () => {\n                    try {\n                        return await (config.execute as ToolFunction<void>)();\n                    } catch (error) {\n                        const errorMessage = error instanceof Error ? error.message : String(error);\n\n                        logger?.error(`Unexpected error in ${config.name}`, {\n                            error: errorMessage,\n                            toolName: config.name,\n                        });\n\n                        return `Tool ${config.name} failed to execute`;\n                    }\n                },\n                name: config.name,\n            });\n        }\n    }\n\n    /**\n     * Get the underlying LangChain DynamicTool instance\n     */\n    getDynamicTool(): DynamicStructuredTool<z.ZodSchema<unknown>> | DynamicTool {\n        return this.dynamicTool as DynamicStructuredTool<z.ZodSchema<unknown>> | DynamicTool;\n    }\n}\n"],"names":["DynamicStructuredTool","DynamicTool","SafeToolAdapter","config","options","dynamicTool","logger","schema","description","func","args","error","errorMessage","execute","Error","message","String","name","toolName","getDynamicTool"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAASA,qBAAqB,EAAEC,WAAW,QAAQ,kBAAkB;AAoBrE;;CAEC,GACD,OAAO,IAAA,AAAMC,gCAAN;;aAAMA,gBAIL,AAAiBC,MAAqB;YACtC,AAAiBC,UAAjB,iEAA+C,CAAC;gCAL3CF;;;QACT,uBAAiBG,eAAjB,KAAA;aAGqBF,SAAAA;aACAC,UAAAA;QAEjB,IAAQE,SAAmBF,QAAnBE,QAAQC,SAAWH,QAAXG;QAEhB,IAAIA,QAAQ;YACR,oDAAoD;YACpD,IAAI,CAACF,WAAW,GAAG,IAAIL,sBAAsB;gBACzCQ,aAAaL,OAAOK,WAAW;gBAC/BC,MAAM,SAAOC;;4BAGAC,OACCC;;;;;;;;;;oCAFC;;wCAAOT,OAAOU,OAAO,CAAqBH;;;oCAAjD;;wCAAO;;;oCACFC;oCACCC,eAAeD,AAAK,YAALA,OAAiBG,SAAQH,MAAMI,OAAO,GAAGC,OAAOL;oCAErEL,mBAAAA,6BAAAA,OAAQK,KAAK,CAAC,AAAC,uBAAkC,OAAZR,OAAOc,IAAI,GAAI;wCAChDP,MAAAA;wCACAC,OAAOC;wCACPM,UAAUf,OAAOc,IAAI;oCACzB;oCAEA;;wCAAQ,QAAmB,OAAZd,OAAOc,IAAI,EAAC;;;;;;;;oBAEnC;;gBACAA,MAAMd,OAAOc,IAAI;gBACjBV,QAAQA;YACZ;QACJ,OAAO;YACH,mCAAmC;YACnC,IAAI,CAACF,WAAW,GAAG,IAAIJ,YAAY;gBAC/BO,aAAaL,OAAOK,WAAW;gBAC/BC,MAAM;;4BAGOE,OACCC;;;;;;;;;;oCAFC;;wCAAOT,OAAOU,OAAO;;;oCAA5B;;wCAAO;;;oCACFF;oCACCC,eAAeD,AAAK,YAALA,OAAiBG,SAAQH,MAAMI,OAAO,GAAGC,OAAOL;oCAErEL,mBAAAA,6BAAAA,OAAQK,KAAK,CAAC,AAAC,uBAAkC,OAAZR,OAAOc,IAAI,GAAI;wCAChDN,OAAOC;wCACPM,UAAUf,OAAOc,IAAI;oCACzB;oCAEA;;wCAAQ,QAAmB,OAAZd,OAAOc,IAAI,EAAC;;;;;;;;oBAEnC;;gBACAA,MAAMd,OAAOc,IAAI;YACrB;QACJ;;kBAnDKf;;YAsDT;;KAEC,GACDiB,KAAAA;mBAAAA,SAAAA;gBACI,OAAO,IAAI,CAACd,WAAW;YAC3B;;;WA3DSH;IA4DZ"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,249 @@
+import { describe, expect, it } from '@jterrazz/test';
+import { z } from 'zod/v4';
+import { AIResponseParser } from '../ai-response-parser.js';
+import { AIResponseParserError } from '../ai-response-parser-error.js';
+// Test data
+var testSchema = z.object({
+    content: z.string(),
+    tags: z.array(z.string()),
+    title: z.string()
+});
+var validJson = {
+    content: 'Test content',
+    tags: [
+        'test',
+        'ai'
+    ],
+    title: 'Test Article'
+};
+var validJsonString = JSON.stringify(validJson);
+describe('AIResponseParser', function() {
+    describe('parse', function() {
+        it('should parse valid JSON object', function() {
+            // Given - a valid JSON object string and parser
+            var text = validJsonString;
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed object
+            expect(result).toEqual(validJson);
+        });
+        it('should parse JSON object with surrounding text', function() {
+            // Given - a JSON object string with surrounding text and parser
+            var text = "Here's the article: ".concat(validJsonString, " - end of article");
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed object
+            expect(result).toEqual(validJson);
+        });
+        it('should parse array response', function() {
+            // Given - a JSON array string and array parser
+            var arraySchema = z.array(z.string());
+            var text = '["test", "ai", "content"]';
+            var parser = new AIResponseParser(arraySchema);
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed array
+            expect(result).toEqual([
+                'test',
+                'ai',
+                'content'
+            ]);
+        });
+        it('should parse primitive string value', function() {
+            // Given - a JSON string value and string parser
+            var text = '"test string"';
+            var parser = new AIResponseParser(z.string());
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed string
+            expect(result).toBe('test string');
+        });
+        it('should parse primitive number value', function() {
+            // Given - a JSON number value and number parser
+            var text = '42';
+            var parser = new AIResponseParser(z.number());
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed number
+            expect(result).toBe(42);
+        });
+        it('should parse primitive boolean value', function() {
+            // Given - a JSON boolean value and boolean parser
+            var text = 'true';
+            var parser = new AIResponseParser(z["boolean"]());
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed boolean
+            expect(result).toBe(true);
+        });
+        it('should parse primitive null value', function() {
+            // Given - a JSON null value and null parser
+            var text = 'null';
+            var parser = new AIResponseParser(z["null"]());
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed null
+            expect(result).toBeNull();
+        });
+        it('should throw ResponseParsingError when JSON is invalid', function() {
+            // Given - an invalid JSON string and parser
+            var text = '{invalid json}';
+            var parser = new AIResponseParser(testSchema);
+            // When/Then - parsing the string should throw a ResponseParsingError
+            expect(function() {
+                return parser.parse(text);
+            }).toThrow(AIResponseParserError);
+        });
+        it('should throw ResponseParsingError when schema validation fails', function() {
+            // Given - an invalid JSON object and parser
+            var invalidJson = {
+                // Should be string
+                content: 'Test content',
+                tags: [
+                    'test',
+                    'ai'
+                ],
+                title: 123
+            };
+            var text = JSON.stringify(invalidJson);
+            var parser = new AIResponseParser(testSchema);
+            // When/Then - parsing the string should throw a ResponseParsingError
+            expect(function() {
+                return parser.parse(text);
+            }).toThrow(AIResponseParserError);
+        });
+        it('should throw ResponseParsingError when no object found in text', function() {
+            // Given - a text without a JSON object and parser
+            var text = 'No JSON object here';
+            var parser = new AIResponseParser(testSchema);
+            // When/Then - parsing the string should throw a ResponseParsingError
+            expect(function() {
+                return parser.parse(text);
+            }).toThrow(AIResponseParserError);
+        });
+        it('should throw ResponseParsingError when no array found in text', function() {
+            // Given - a text without a JSON array and array parser
+            var text = 'No array here';
+            var arraySchema = z.array(z.string());
+            var parser = new AIResponseParser(arraySchema);
+            // When/Then - parsing the string should throw a ResponseParsingError
+            expect(function() {
+                return parser.parse(text);
+            }).toThrow(AIResponseParserError);
+        });
+        it('should throw ResponseParsingError for unsupported schema type', function() {
+            // Given - a text with an unsupported schema type and parser
+            var text = 'test';
+            var unsupportedSchema = z.union([
+                z.string(),
+                z.number()
+            ]);
+            var parser = new AIResponseParser(unsupportedSchema);
+            // When/Then - parsing the string should throw a ResponseParsingError
+            expect(function() {
+                return parser.parse(text);
+            }).toThrow(AIResponseParserError);
+        });
+        it('should include original text in error when parsing fails', function() {
+            // Given - an invalid JSON string and parser
+            var text = '{invalid json}';
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            try {
+                parser.parse(text);
+                throw new Error('Should have thrown an error');
+            } catch (error) {
+                // Then - the error should include the original text
+                expect(error).toBeInstanceOf(AIResponseParserError);
+                expect(error.text).toBe(text);
+            }
+        });
+        it('should handle text with newlines in JSON object', function() {
+            // Given - a JSON object with newlines and parser
+            var textWithNewlines = '{\n                "content": "Test\ncontent\nwith\nnewlines",\n                "tags": ["test", "ai"],\n                "title": "Test\nArticle"\n            }';
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            var result = parser.parse(textWithNewlines);
+            // Then - it should return the parsed object
+            expect(result).toEqual({
+                content: 'Test content with newlines',
+                tags: [
+                    'test',
+                    'ai'
+                ],
+                title: 'Test Article'
+            });
+        });
+        it('should handle text with newlines in surrounding text', function() {
+            // Given - a text with newlines around the JSON object and parser
+            var textWithNewlines = "Here's the\narticle:\n".concat(validJsonString, "\n- end of\narticle");
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            var result = parser.parse(textWithNewlines);
+            // Then - it should return the parsed object
+            expect(result).toEqual(validJson);
+        });
+        it('should handle text with multiple consecutive newlines and spaces', function() {
+            // Given - a text with multiple consecutive newlines and spaces and parser
+            var textWithNewlines = "Here's the\n\n  article:   \n\n".concat(validJsonString, "\n\n");
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            var result = parser.parse(textWithNewlines);
+            // Then - it should return the parsed object
+            expect(result).toEqual(validJson);
+        });
+        it('should handle escaped characters in JSON', function() {
+            // Given - a JSON string with escaped characters and parser
+            var text = '{"content": "Test\\ncontent\\twith\\r\\nescapes", "tags": ["test\\u0020ai", "escaped\\"quotes\\""], "title": "Test\\\\Article"}';
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed object
+            expect(result).toEqual({
+                content: 'Test\ncontent\twith\r\nescapes',
+                tags: [
+                    'test ai',
+                    'escaped"quotes"'
+                ],
+                title: 'Test\\Article'
+            });
+        });
+        it('should handle escaped characters in markdown code blocks', function() {
+            // Given - a markdown code block with escaped characters and parser
+            var text = '```json\n{"content": "Test\\nContent", "tags": ["test\\u0020ai"], "title": "Test\\\\Title"}\n```';
+            var parser = new AIResponseParser(testSchema);
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed object
+            expect(result).toEqual({
+                content: 'Test\nContent',
+                tags: [
+                    'test ai'
+                ],
+                title: 'Test\\Title'
+            });
+        });
+        it('should handle escaped characters in markdown code blocks', function() {
+            // Given - a markdown code block with escaped characters and array parser
+            var text = '```json\n [\n{"content": "Test\\nContent", "tags": ["test\\u0020ai"], "title": "Test\\\\Title"}\n]\n```';
+            var arraySchema = z.array(testSchema);
+            var parser = new AIResponseParser(arraySchema);
+            // When - parsing the string
+            var result = parser.parse(text);
+            // Then - it should return the parsed array
+            expect(result).toEqual([
+                {
+                    content: 'Test\nContent',
+                    tags: [
+                        'test ai'
+                    ],
+                    title: 'Test\\Title'
+                }
+            ]);
+        });
+    });
+});
+
+//# sourceMappingURL=ai-response-parser.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/adapters/utils/__tests__/ai-response-parser.test.ts"],"sourcesContent":["import { describe, expect, it } from '@jterrazz/test';\nimport { z } from 'zod/v4';\n\nimport { AIResponseParser } from '../ai-response-parser.js';\nimport { AIResponseParserError } from '../ai-response-parser-error.js';\n\n// Test data\nconst testSchema = z.object({\n    content: z.string(),\n    tags: z.array(z.string()),\n    title: z.string(),\n});\n\nconst validJson = {\n    content: 'Test content',\n    tags: ['test', 'ai'],\n    title: 'Test Article',\n};\n\nconst validJsonString = JSON.stringify(validJson);\n\ndescribe('AIResponseParser', () => {\n    describe('parse', () => {\n        it('should parse valid JSON object', () => {\n            // Given - a valid JSON object string and parser\n            const text = validJsonString;\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed object\n            expect(result).toEqual(validJson);\n        });\n\n        it('should parse JSON object with surrounding text', () => {\n            // Given - a JSON object string with surrounding text and parser\n            const text = `Here's the article: ${validJsonString} - end of article`;\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed object\n            expect(result).toEqual(validJson);\n        });\n\n        it('should parse array response', () => {\n            // Given - a JSON array string and array parser\n            const arraySchema = z.array(z.string());\n            const text = '[\"test\", \"ai\", \"content\"]';\n            const parser = new AIResponseParser(arraySchema);\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed array\n            expect(result).toEqual(['test', 'ai', 'content']);\n        });\n\n        it('should parse primitive string value', () => {\n            // Given - a JSON string value and string parser\n            const text = '\"test string\"';\n            const parser = new AIResponseParser(z.string());\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed string\n            expect(result).toBe('test string');\n        });\n\n        it('should parse primitive number value', () => {\n            // Given - a JSON number value and number parser\n            const text = '42';\n            const parser = new AIResponseParser(z.number());\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed number\n            expect(result).toBe(42);\n        });\n\n        it('should parse primitive boolean value', () => {\n            // Given - a JSON boolean value and boolean parser\n            const text = 'true';\n            const parser = new AIResponseParser(z.boolean());\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed boolean\n            expect(result).toBe(true);\n        });\n\n        it('should parse primitive null value', () => {\n            // Given - a JSON null value and null parser\n            const text = 'null';\n            const parser = new AIResponseParser(z.null());\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed null\n            expect(result).toBeNull();\n        });\n\n        it('should throw ResponseParsingError when JSON is invalid', () => {\n            // Given - an invalid JSON string and parser\n            const text = '{invalid json}';\n            const parser = new AIResponseParser(testSchema);\n\n            // When/Then - parsing the string should throw a ResponseParsingError\n            expect(() => parser.parse(text)).toThrow(AIResponseParserError);\n        });\n\n        it('should throw ResponseParsingError when schema validation fails', () => {\n            // Given - an invalid JSON object and parser\n            const invalidJson = {\n                // Should be string\n                content: 'Test content',\n                tags: ['test', 'ai'],\n                title: 123,\n            };\n            const text = JSON.stringify(invalidJson);\n            const parser = new AIResponseParser(testSchema);\n\n            // When/Then - parsing the string should throw a ResponseParsingError\n            expect(() => parser.parse(text)).toThrow(AIResponseParserError);\n        });\n\n        it('should throw ResponseParsingError when no object found in text', () => {\n            // Given - a text without a JSON object and parser\n            const text = 'No JSON object here';\n            const parser = new AIResponseParser(testSchema);\n\n            // When/Then - parsing the string should throw a ResponseParsingError\n            expect(() => parser.parse(text)).toThrow(AIResponseParserError);\n        });\n\n        it('should throw ResponseParsingError when no array found in text', () => {\n            // Given - a text without a JSON array and array parser\n            const text = 'No array here';\n            const arraySchema = z.array(z.string());\n            const parser = new AIResponseParser(arraySchema);\n\n            // When/Then - parsing the string should throw a ResponseParsingError\n            expect(() => parser.parse(text)).toThrow(AIResponseParserError);\n        });\n\n        it('should throw ResponseParsingError for unsupported schema type', () => {\n            // Given - a text with an unsupported schema type and parser\n            const text = 'test';\n            const unsupportedSchema = z.union([z.string(), z.number()]);\n            const parser = new AIResponseParser(unsupportedSchema);\n\n            // When/Then - parsing the string should throw a ResponseParsingError\n            expect(() => parser.parse(text)).toThrow(AIResponseParserError);\n        });\n\n        it('should include original text in error when parsing fails', () => {\n            // Given - an invalid JSON string and parser\n            const text = '{invalid json}';\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            try {\n                parser.parse(text);\n                throw new Error('Should have thrown an error');\n            } catch (error) {\n                // Then - the error should include the original text\n                expect(error).toBeInstanceOf(AIResponseParserError);\n                expect((error as AIResponseParserError).text).toBe(text);\n            }\n        });\n\n        it('should handle text with newlines in JSON object', () => {\n            // Given - a JSON object with newlines and parser\n            const textWithNewlines = `{\n                \"content\": \"Test\\ncontent\\nwith\\nnewlines\",\n                \"tags\": [\"test\", \"ai\"],\n                \"title\": \"Test\\nArticle\"\n            }`;\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            const result = parser.parse(textWithNewlines);\n\n            // Then - it should return the parsed object\n            expect(result).toEqual({\n                content: 'Test content with newlines',\n                tags: ['test', 'ai'],\n                title: 'Test Article',\n            });\n        });\n\n        it('should handle text with newlines in surrounding text', () => {\n            // Given - a text with newlines around the JSON object and parser\n            const textWithNewlines = `Here's the\\narticle:\\n${validJsonString}\\n- end of\\narticle`;\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            const result = parser.parse(textWithNewlines);\n\n            // Then - it should return the parsed object\n            expect(result).toEqual(validJson);\n        });\n\n        it('should handle text with multiple consecutive newlines and spaces', () => {\n            // Given - a text with multiple consecutive newlines and spaces and parser\n            const textWithNewlines = `Here's the\\n\\n  article:   \\n\\n${validJsonString}\\n\\n`;\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            const result = parser.parse(textWithNewlines);\n\n            // Then - it should return the parsed object\n            expect(result).toEqual(validJson);\n        });\n\n        it('should handle escaped characters in JSON', () => {\n            // Given - a JSON string with escaped characters and parser\n            const text =\n                '{\"content\": \"Test\\\\ncontent\\\\twith\\\\r\\\\nescapes\", \"tags\": [\"test\\\\u0020ai\", \"escaped\\\\\"quotes\\\\\"\"], \"title\": \"Test\\\\\\\\Article\"}';\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed object\n            expect(result).toEqual({\n                content: 'Test\\ncontent\\twith\\r\\nescapes',\n                tags: ['test ai', 'escaped\"quotes\"'],\n                title: 'Test\\\\Article',\n            });\n        });\n\n        it('should handle escaped characters in markdown code blocks', () => {\n            // Given - a markdown code block with escaped characters and parser\n            const text =\n                '```json\\n{\"content\": \"Test\\\\nContent\", \"tags\": [\"test\\\\u0020ai\"], \"title\": \"Test\\\\\\\\Title\"}\\n```';\n            const parser = new AIResponseParser(testSchema);\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed object\n            expect(result).toEqual({\n                content: 'Test\\nContent',\n                tags: ['test ai'],\n                title: 'Test\\\\Title',\n            });\n        });\n\n        it('should handle escaped characters in markdown code blocks', () => {\n            // Given - a markdown code block with escaped characters and array parser\n            const text =\n                '```json\\n [\\n{\"content\": \"Test\\\\nContent\", \"tags\": [\"test\\\\u0020ai\"], \"title\": \"Test\\\\\\\\Title\"}\\n]\\n```';\n            const arraySchema = z.array(testSchema);\n            const parser = new AIResponseParser(arraySchema);\n\n            // When - parsing the string\n            const result = parser.parse(text);\n\n            // Then - it should return the parsed array\n            expect(result).toEqual([\n                {\n                    content: 'Test\\nContent',\n                    tags: ['test ai'],\n                    title: 'Test\\\\Title',\n                },\n            ]);\n        });\n    });\n});\n"],"names":["describe","expect","it","z","AIResponseParser","AIResponseParserError","testSchema","object","content","string","tags","array","title","validJson","validJsonString","JSON","stringify","text","parser","result","parse","toEqual","arraySchema","toBe","number","boolean","null","toBeNull","toThrow","invalidJson","unsupportedSchema","union","Error","error","toBeInstanceOf","textWithNewlines"],"mappings":"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"}

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

@@ -0,0 +1,8 @@
+/**
+ * Custom error for AI response parsing failures
+ */
+export declare class AIResponseParserError extends Error {
+    readonly cause?: unknown | undefined;
+    readonly text?: string | undefined;
+    constructor(message: string, cause?: unknown | undefined, text?: string | undefined);
+}

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

@@ -0,0 +1,136 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,56 @@
+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;
+    /**
+     * Recursively unescapes all string values in a JSON object/array
+     */
+    private unescapeJsonValues;
+    /**
+     * Unescapes common escaped characters in text
+     */
+    private unescapeText;
+}