@jterrazz/intelligence 2.0.0 → 3.0.1

package/dist/parsing/__tests__/parse-text.test.js

@@ -0,0 +1,167 @@
+import { describe, expect, it } from 'vitest';
+import { parseText } from '../parse-text.js';
+describe('parseText', function() {
+    describe('empty and basic input', function() {
+        it('returns empty string for empty input', function() {
+            expect(parseText('')).toBe('');
+        });
+        it('returns trimmed text for simple input', function() {
+            expect(parseText('  hello world  ')).toBe('hello world');
+        });
+        it('preserves newlines', function() {
+            expect(parseText('hello\nworld')).toBe('hello\nworld');
+        });
+    });
+    describe('BOM handling', function() {
+        it('removes BOM character at start', function() {
+            expect(parseText('\uFEFFhello')).toBe('hello');
+        });
+        it('removes BOM in middle of text (via invisible char removal)', function() {
+            expect(parseText('hello\uFEFFworld')).toBe('helloworld');
+        });
+    });
+    describe('line ending normalization', function() {
+        it('converts CRLF to LF', function() {
+            expect(parseText('hello\r\nworld')).toBe('hello\nworld');
+        });
+        it('converts standalone CR to LF', function() {
+            expect(parseText('hello\rworld')).toBe('hello\nworld');
+        });
+    });
+    describe('AI citation removal', function() {
+        it('removes oaicite markers', function() {
+            expect(parseText('Some text (oaicite:0){index=0} more text')).toBe('Some text more text');
+        });
+        it('removes multiple citation markers', function() {
+            expect(parseText('Text (oaicite:1){index=1} and (oaicite:2){index=2} here')).toBe('Text and here');
+        });
+    });
+    describe('invisible character removal', function() {
+        it('removes zero-width space', function() {
+            expect(parseText('hello\u200Bworld')).toBe('helloworld');
+        });
+        it('removes zero-width non-joiner', function() {
+            expect(parseText('hello\u200Cworld')).toBe('helloworld');
+        });
+        it('removes soft hyphen', function() {
+            expect(parseText('hello\u00ADworld')).toBe('helloworld');
+        });
+        it('removes direction marks', function() {
+            expect(parseText('hello\u200E\u200Fworld')).toBe('helloworld');
+        });
+        it('removes word joiner', function() {
+            expect(parseText('hello\u2060world')).toBe('helloworld');
+        });
+    });
+    describe('ASCII control character removal', function() {
+        it('removes null character', function() {
+            expect(parseText('hello\x00world')).toBe('helloworld');
+        });
+        it('removes bell character', function() {
+            expect(parseText('hello\x07world')).toBe('helloworld');
+        });
+        it('removes delete character', function() {
+            expect(parseText('hello\x7Fworld')).toBe('helloworld');
+        });
+        it('preserves tab and newline', function() {
+            expect(parseText('hello\tworld\n!')).toBe('hello\tworld\n!');
+        });
+    });
+    describe('em/en dash normalization', function() {
+        it('converts em dash with spaces to comma', function() {
+            expect(parseText('hello — world')).toBe('hello, world');
+        });
+        it('converts en dash with spaces to comma', function() {
+            expect(parseText('hello – world')).toBe('hello, world');
+        });
+        it('converts horizontal bar with spaces to comma', function() {
+            expect(parseText('hello ― world')).toBe('hello, world');
+        });
+        it('converts figure dash with spaces to comma', function() {
+            expect(parseText('hello ‒ world')).toBe('hello, world');
+        });
+        it('converts em dash without spaces to comma', function() {
+            expect(parseText('disparaître—ne laissant')).toBe('disparaître, ne laissant');
+        });
+        it('can be disabled via options', function() {
+            expect(parseText('hello — world', {
+                normalizeEmDashesToCommas: false
+            })).toBe('hello — world');
+        });
+        it('preserves em dash when disabled (no spaces)', function() {
+            expect(parseText('word—word', {
+                normalizeEmDashesToCommas: false
+            })).toBe('word—word');
+        });
+    });
+    describe('space-like character normalization', function() {
+        it('converts non-breaking space to regular space', function() {
+            expect(parseText('hello\u00A0world')).toBe('hello world');
+        });
+        it('converts em space to regular space', function() {
+            expect(parseText('hello\u2003world')).toBe('hello world');
+        });
+        it('converts narrow no-break space to regular space', function() {
+            expect(parseText('hello\u202Fworld')).toBe('hello world');
+        });
+        it('converts ideographic space to regular space', function() {
+            expect(parseText('hello\u3000world')).toBe('hello world');
+        });
+    });
+    describe('typography normalization', function() {
+        it('converts left single quote to straight quote', function() {
+            expect(parseText('it\u2018s')).toBe("it's");
+        });
+        it('converts right single quote to straight quote', function() {
+            expect(parseText('it\u2019s')).toBe("it's");
+        });
+        it('converts left double quote to straight quote', function() {
+            expect(parseText('\u201CHello\u201D')).toBe('"Hello"');
+        });
+        it('converts em dash to comma', function() {
+            expect(parseText('word\u2014word')).toBe('word, word');
+        });
+        it('converts en dash to comma', function() {
+            expect(parseText('2020\u20132021')).toBe('2020, 2021');
+        });
+        it('converts ellipsis to three dots', function() {
+            expect(parseText('wait\u2026')).toBe('wait...');
+        });
+        it('converts bullet point to hyphen', function() {
+            expect(parseText('\u2022 item')).toBe('- item');
+        });
+    });
+    describe('multiple space collapsing', function() {
+        it('collapses multiple spaces to single space', function() {
+            expect(parseText('hello    world')).toBe('hello world');
+        });
+        it('trims leading and trailing spaces', function() {
+            expect(parseText('   hello world   ')).toBe('hello world');
+        });
+        it('can be disabled via options', function() {
+            expect(parseText('hello    world', {
+                collapseSpaces: false
+            })).toBe('hello    world');
+        });
+    });
+    describe('NFKC normalization', function() {
+        it('normalizes fullwidth characters', function() {
+            expect(parseText('\uFF21\uFF22\uFF23')).toBe('ABC');
+        });
+        it('normalizes ligatures', function() {
+            expect(parseText('\uFB01le')).toBe('file');
+        });
+    });
+    describe('combined scenarios', function() {
+        it('handles AI-generated text with multiple issues', function() {
+            var input = '\uFEFF  Hello\u2019s world (oaicite:0){index=0} \u2014 with\u00A0spaces  ';
+            expect(parseText(input)).toBe("Hello's world, with spaces");
+        });
+        it('handles markdown with smart quotes and dashes', function() {
+            var input = '\u201CThis is a quote\u201D \u2014 Author';
+            expect(parseText(input)).toBe('"This is a quote", Author');
+        });
+    });
+});
+
+//# sourceMappingURL=parse-text.test.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/parsing/__tests__/parse-text.test.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest';\n\nimport { parseText } from '../parse-text.js';\n\ndescribe('parseText', () => {\n    describe('empty and basic input', () => {\n        it('returns empty string for empty input', () => {\n            expect(parseText('')).toBe('');\n        });\n\n        it('returns trimmed text for simple input', () => {\n            expect(parseText('  hello world  ')).toBe('hello world');\n        });\n\n        it('preserves newlines', () => {\n            expect(parseText('hello\\nworld')).toBe('hello\\nworld');\n        });\n    });\n\n    describe('BOM handling', () => {\n        it('removes BOM character at start', () => {\n            expect(parseText('\\uFEFFhello')).toBe('hello');\n        });\n\n        it('removes BOM in middle of text (via invisible char removal)', () => {\n            expect(parseText('hello\\uFEFFworld')).toBe('helloworld');\n        });\n    });\n\n    describe('line ending normalization', () => {\n        it('converts CRLF to LF', () => {\n            expect(parseText('hello\\r\\nworld')).toBe('hello\\nworld');\n        });\n\n        it('converts standalone CR to LF', () => {\n            expect(parseText('hello\\rworld')).toBe('hello\\nworld');\n        });\n    });\n\n    describe('AI citation removal', () => {\n        it('removes oaicite markers', () => {\n            expect(parseText('Some text (oaicite:0){index=0} more text')).toBe(\n                'Some text more text',\n            );\n        });\n\n        it('removes multiple citation markers', () => {\n            expect(parseText('Text (oaicite:1){index=1} and (oaicite:2){index=2} here')).toBe(\n                'Text and here',\n            );\n        });\n    });\n\n    describe('invisible character removal', () => {\n        it('removes zero-width space', () => {\n            expect(parseText('hello\\u200Bworld')).toBe('helloworld');\n        });\n\n        it('removes zero-width non-joiner', () => {\n            expect(parseText('hello\\u200Cworld')).toBe('helloworld');\n        });\n\n        it('removes soft hyphen', () => {\n            expect(parseText('hello\\u00ADworld')).toBe('helloworld');\n        });\n\n        it('removes direction marks', () => {\n            expect(parseText('hello\\u200E\\u200Fworld')).toBe('helloworld');\n        });\n\n        it('removes word joiner', () => {\n            expect(parseText('hello\\u2060world')).toBe('helloworld');\n        });\n    });\n\n    describe('ASCII control character removal', () => {\n        it('removes null character', () => {\n            expect(parseText('hello\\x00world')).toBe('helloworld');\n        });\n\n        it('removes bell character', () => {\n            expect(parseText('hello\\x07world')).toBe('helloworld');\n        });\n\n        it('removes delete character', () => {\n            expect(parseText('hello\\x7Fworld')).toBe('helloworld');\n        });\n\n        it('preserves tab and newline', () => {\n            expect(parseText('hello\\tworld\\n!')).toBe('hello\\tworld\\n!');\n        });\n    });\n\n    describe('em/en dash normalization', () => {\n        it('converts em dash with spaces to comma', () => {\n            expect(parseText('hello — world')).toBe('hello, world');\n        });\n\n        it('converts en dash with spaces to comma', () => {\n            expect(parseText('hello – world')).toBe('hello, world');\n        });\n\n        it('converts horizontal bar with spaces to comma', () => {\n            expect(parseText('hello ― world')).toBe('hello, world');\n        });\n\n        it('converts figure dash with spaces to comma', () => {\n            expect(parseText('hello ‒ world')).toBe('hello, world');\n        });\n\n        it('converts em dash without spaces to comma', () => {\n            expect(parseText('disparaître—ne laissant')).toBe('disparaître, ne laissant');\n        });\n\n        it('can be disabled via options', () => {\n            expect(parseText('hello — world', { normalizeEmDashesToCommas: false })).toBe(\n                'hello — world',\n            );\n        });\n\n        it('preserves em dash when disabled (no spaces)', () => {\n            expect(parseText('word—word', { normalizeEmDashesToCommas: false })).toBe('word—word');\n        });\n    });\n\n    describe('space-like character normalization', () => {\n        it('converts non-breaking space to regular space', () => {\n            expect(parseText('hello\\u00A0world')).toBe('hello world');\n        });\n\n        it('converts em space to regular space', () => {\n            expect(parseText('hello\\u2003world')).toBe('hello world');\n        });\n\n        it('converts narrow no-break space to regular space', () => {\n            expect(parseText('hello\\u202Fworld')).toBe('hello world');\n        });\n\n        it('converts ideographic space to regular space', () => {\n            expect(parseText('hello\\u3000world')).toBe('hello world');\n        });\n    });\n\n    describe('typography normalization', () => {\n        it('converts left single quote to straight quote', () => {\n            expect(parseText('it\\u2018s')).toBe(\"it's\");\n        });\n\n        it('converts right single quote to straight quote', () => {\n            expect(parseText('it\\u2019s')).toBe(\"it's\");\n        });\n\n        it('converts left double quote to straight quote', () => {\n            expect(parseText('\\u201CHello\\u201D')).toBe('\"Hello\"');\n        });\n\n        it('converts em dash to comma', () => {\n            expect(parseText('word\\u2014word')).toBe('word, word');\n        });\n\n        it('converts en dash to comma', () => {\n            expect(parseText('2020\\u20132021')).toBe('2020, 2021');\n        });\n\n        it('converts ellipsis to three dots', () => {\n            expect(parseText('wait\\u2026')).toBe('wait...');\n        });\n\n        it('converts bullet point to hyphen', () => {\n            expect(parseText('\\u2022 item')).toBe('- item');\n        });\n    });\n\n    describe('multiple space collapsing', () => {\n        it('collapses multiple spaces to single space', () => {\n            expect(parseText('hello    world')).toBe('hello world');\n        });\n\n        it('trims leading and trailing spaces', () => {\n            expect(parseText('   hello world   ')).toBe('hello world');\n        });\n\n        it('can be disabled via options', () => {\n            expect(parseText('hello    world', { collapseSpaces: false })).toBe('hello    world');\n        });\n    });\n\n    describe('NFKC normalization', () => {\n        it('normalizes fullwidth characters', () => {\n            expect(parseText('\\uFF21\\uFF22\\uFF23')).toBe('ABC');\n        });\n\n        it('normalizes ligatures', () => {\n            expect(parseText('\\uFB01le')).toBe('file');\n        });\n    });\n\n    describe('combined scenarios', () => {\n        it('handles AI-generated text with multiple issues', () => {\n            const input =\n                '\\uFEFF  Hello\\u2019s world (oaicite:0){index=0} \\u2014 with\\u00A0spaces  ';\n            expect(parseText(input)).toBe(\"Hello's world, with spaces\");\n        });\n\n        it('handles markdown with smart quotes and dashes', () => {\n            const input = '\\u201CThis is a quote\\u201D \\u2014 Author';\n            expect(parseText(input)).toBe('\"This is a quote\", Author');\n        });\n    });\n});\n"],"names":["describe","expect","it","parseText","toBe","normalizeEmDashesToCommas","collapseSpaces","input"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAS;AAE9C,SAASC,SAAS,QAAQ,mBAAmB;AAE7CH,SAAS,aAAa;IAClBA,SAAS,yBAAyB;QAC9BE,GAAG,wCAAwC;YACvCD,OAAOE,UAAU,KAAKC,IAAI,CAAC;QAC/B;QAEAF,GAAG,yCAAyC;YACxCD,OAAOE,UAAU,oBAAoBC,IAAI,CAAC;QAC9C;QAEAF,GAAG,sBAAsB;YACrBD,OAAOE,UAAU,iBAAiBC,IAAI,CAAC;QAC3C;IACJ;IAEAJ,SAAS,gBAAgB;QACrBE,GAAG,kCAAkC;YACjCD,OAAOE,UAAU,gBAAgBC,IAAI,CAAC;QAC1C;QAEAF,GAAG,8DAA8D;YAC7DD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;IACJ;IAEAJ,SAAS,6BAA6B;QAClCE,GAAG,uBAAuB;YACtBD,OAAOE,UAAU,mBAAmBC,IAAI,CAAC;QAC7C;QAEAF,GAAG,gCAAgC;YAC/BD,OAAOE,UAAU,iBAAiBC,IAAI,CAAC;QAC3C;IACJ;IAEAJ,SAAS,uBAAuB;QAC5BE,GAAG,2BAA2B;YAC1BD,OAAOE,UAAU,6CAA6CC,IAAI,CAC9D;QAER;QAEAF,GAAG,qCAAqC;YACpCD,OAAOE,UAAU,4DAA4DC,IAAI,CAC7E;QAER;IACJ;IAEAJ,SAAS,+BAA+B;QACpCE,GAAG,4BAA4B;YAC3BD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;QAEAF,GAAG,iCAAiC;YAChCD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;QAEAF,GAAG,uBAAuB;YACtBD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;QAEAF,GAAG,2BAA2B;YAC1BD,OAAOE,UAAU,2BAA2BC,IAAI,CAAC;QACrD;QAEAF,GAAG,uBAAuB;YACtBD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;IACJ;IAEAJ,SAAS,mCAAmC;QACxCE,GAAG,0BAA0B;YACzBD,OAAOE,UAAU,mBAAmBC,IAAI,CAAC;QAC7C;QAEAF,GAAG,0BAA0B;YACzBD,OAAOE,UAAU,mBAAmBC,IAAI,CAAC;QAC7C;QAEAF,GAAG,4BAA4B;YAC3BD,OAAOE,UAAU,mBAAmBC,IAAI,CAAC;QAC7C;QAEAF,GAAG,6BAA6B;YAC5BD,OAAOE,UAAU,oBAAoBC,IAAI,CAAC;QAC9C;IACJ;IAEAJ,SAAS,4BAA4B;QACjCE,GAAG,yCAAyC;YACxCD,OAAOE,UAAU,kBAAkBC,IAAI,CAAC;QAC5C;QAEAF,GAAG,yCAAyC;YACxCD,OAAOE,UAAU,kBAAkBC,IAAI,CAAC;QAC5C;QAEAF,GAAG,gDAAgD;YAC/CD,OAAOE,UAAU,kBAAkBC,IAAI,CAAC;QAC5C;QAEAF,GAAG,6CAA6C;YAC5CD,OAAOE,UAAU,kBAAkBC,IAAI,CAAC;QAC5C;QAEAF,GAAG,4CAA4C;YAC3CD,OAAOE,UAAU,4BAA4BC,IAAI,CAAC;QACtD;QAEAF,GAAG,+BAA+B;YAC9BD,OAAOE,UAAU,iBAAiB;gBAAEE,2BAA2B;YAAM,IAAID,IAAI,CACzE;QAER;QAEAF,GAAG,+CAA+C;YAC9CD,OAAOE,UAAU,aAAa;gBAAEE,2BAA2B;YAAM,IAAID,IAAI,CAAC;QAC9E;IACJ;IAEAJ,SAAS,sCAAsC;QAC3CE,GAAG,gDAAgD;YAC/CD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;QAEAF,GAAG,sCAAsC;YACrCD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;QAEAF,GAAG,mDAAmD;YAClDD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;QAEAF,GAAG,+CAA+C;YAC9CD,OAAOE,UAAU,qBAAqBC,IAAI,CAAC;QAC/C;IACJ;IAEAJ,SAAS,4BAA4B;QACjCE,GAAG,gDAAgD;YAC/CD,OAAOE,UAAU,cAAcC,IAAI,CAAC;QACxC;QAEAF,GAAG,iDAAiD;YAChDD,OAAOE,UAAU,cAAcC,IAAI,CAAC;QACxC;QAEAF,GAAG,gDAAgD;YAC/CD,OAAOE,UAAU,sBAAsBC,IAAI,CAAC;QAChD;QAEAF,GAAG,6BAA6B;YAC5BD,OAAOE,UAAU,mBAAmBC,IAAI,CAAC;QAC7C;QAEAF,GAAG,6BAA6B;YAC5BD,OAAOE,UAAU,mBAAmBC,IAAI,CAAC;QAC7C;QAEAF,GAAG,mCAAmC;YAClCD,OAAOE,UAAU,eAAeC,IAAI,CAAC;QACzC;QAEAF,GAAG,mCAAmC;YAClCD,OAAOE,UAAU,gBAAgBC,IAAI,CAAC;QAC1C;IACJ;IAEAJ,SAAS,6BAA6B;QAClCE,GAAG,6CAA6C;YAC5CD,OAAOE,UAAU,mBAAmBC,IAAI,CAAC;QAC7C;QAEAF,GAAG,qCAAqC;YACpCD,OAAOE,UAAU,sBAAsBC,IAAI,CAAC;QAChD;QAEAF,GAAG,+BAA+B;YAC9BD,OAAOE,UAAU,kBAAkB;gBAAEG,gBAAgB;YAAM,IAAIF,IAAI,CAAC;QACxE;IACJ;IAEAJ,SAAS,sBAAsB;QAC3BE,GAAG,mCAAmC;YAClCD,OAAOE,UAAU,uBAAuBC,IAAI,CAAC;QACjD;QAEAF,GAAG,wBAAwB;YACvBD,OAAOE,UAAU,aAAaC,IAAI,CAAC;QACvC;IACJ;IAEAJ,SAAS,sBAAsB;QAC3BE,GAAG,kDAAkD;YACjD,IAAMK,QACF;YACJN,OAAOE,UAAUI,QAAQH,IAAI,CAAC;QAClC;QAEAF,GAAG,iDAAiD;YAChD,IAAMK,QAAQ;YACdN,OAAOE,UAAUI,QAAQH,IAAI,CAAC;QAClC;IACJ;AACJ"}

package/dist/parsing/create-schema-prompt.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod/v4';
+/**
+ * Creates a system prompt that instructs the model to output structured data
+ * matching the provided Zod schema.
+ *
+ * Use this with `generateText` when the provider doesn't support native
+ * structured outputs, then parse the response with `parseObject`.
+ *
+ * @param schema - A Zod schema defining the expected output structure
+ * @returns A system prompt string with JSON schema instructions
+ *
+ * @example
+ * ```ts
+ * import { generateText } from 'ai';
+ * import { createSchemaPrompt, parseObject } from '@jterrazz/intelligence';
+ *
+ * const schema = z.object({ title: z.string(), tags: z.array(z.string()) });
+ *
+ * const { text } = await generateText({
+ *   model,
+ *   prompt: 'Generate an article about TypeScript',
+ *   system: createSchemaPrompt(schema),
+ * });
+ *
+ * const result = parseObject(text, schema);
+ * ```
+ */
+export declare function createSchemaPrompt<T>(schema: z.ZodType<T>): string;

package/dist/parsing/create-schema-prompt.js

@@ -0,0 +1,42 @@
+import { z } from 'zod/v4';
+/**
+ * Creates a system prompt that instructs the model to output structured data
+ * matching the provided Zod schema.
+ *
+ * Use this with `generateText` when the provider doesn't support native
+ * structured outputs, then parse the response with `parseObject`.
+ *
+ * @param schema - A Zod schema defining the expected output structure
+ * @returns A system prompt string with JSON schema instructions
+ *
+ * @example
+ * ```ts
+ * import { generateText } from 'ai';
+ * import { createSchemaPrompt, parseObject } from '@jterrazz/intelligence';
+ *
+ * const schema = z.object({ title: z.string(), tags: z.array(z.string()) });
+ *
+ * const { text } = await generateText({
+ *   model,
+ *   prompt: 'Generate an article about TypeScript',
+ *   system: createSchemaPrompt(schema),
+ * });
+ *
+ * const result = parseObject(text, schema);
+ * ```
+ */ export function createSchemaPrompt(schema) {
+    var jsonSchema = z.toJSONSchema(schema);
+    var schemaJson = JSON.stringify(jsonSchema, null, 2);
+    var isPrimitive = [
+        'boolean',
+        'integer',
+        'number',
+        'string'
+    ].includes(jsonSchema.type);
+    if (isPrimitive) {
+        return "<OUTPUT_FORMAT>\nYou must respond with a ".concat(jsonSchema.type, " value that matches this schema:\n\n```json\n").concat(schemaJson, "\n```\n\nYour response should be only the ").concat(jsonSchema.type, " value, without any JSON wrapping or additional text.\n</OUTPUT_FORMAT>");
+    }
+    return "<OUTPUT_FORMAT>\nYou must respond with valid JSON that matches this JSON schema:\n\n```json\n".concat(schemaJson, "\n```\n\nYour response must be parseable JSON that validates against this schema. Do not include any text outside the JSON.\n</OUTPUT_FORMAT>");
+}
+
+//# sourceMappingURL=create-schema-prompt.js.map

package/dist/parsing/create-schema-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/parsing/create-schema-prompt.ts"],"sourcesContent":["import { z } from 'zod/v4';\n\n/**\n * Creates a system prompt that instructs the model to output structured data\n * matching the provided Zod schema.\n *\n * Use this with `generateText` when the provider doesn't support native\n * structured outputs, then parse the response with `parseObject`.\n *\n * @param schema - A Zod schema defining the expected output structure\n * @returns A system prompt string with JSON schema instructions\n *\n * @example\n * ```ts\n * import { generateText } from 'ai';\n * import { createSchemaPrompt, parseObject } from '@jterrazz/intelligence';\n *\n * const schema = z.object({ title: z.string(), tags: z.array(z.string()) });\n *\n * const { text } = await generateText({\n *   model,\n *   prompt: 'Generate an article about TypeScript',\n *   system: createSchemaPrompt(schema),\n * });\n *\n * const result = parseObject(text, schema);\n * ```\n */\nexport function createSchemaPrompt<T>(schema: z.ZodType<T>): string {\n    const jsonSchema = z.toJSONSchema(schema);\n    const schemaJson = JSON.stringify(jsonSchema, null, 2);\n\n    const isPrimitive = ['boolean', 'integer', 'number', 'string'].includes(\n        jsonSchema.type as string,\n    );\n\n    if (isPrimitive) {\n        return `<OUTPUT_FORMAT>\nYou must respond with a ${jsonSchema.type} value that matches this schema:\n\n\\`\\`\\`json\n${schemaJson}\n\\`\\`\\`\n\nYour response should be only the ${jsonSchema.type} value, without any JSON wrapping or additional text.\n</OUTPUT_FORMAT>`;\n    }\n\n    return `<OUTPUT_FORMAT>\nYou must respond with valid JSON that matches this JSON schema:\n\n\\`\\`\\`json\n${schemaJson}\n\\`\\`\\`\n\nYour response must be parseable JSON that validates against this schema. Do not include any text outside the JSON.\n</OUTPUT_FORMAT>`;\n}\n"],"names":["z","createSchemaPrompt","schema","jsonSchema","toJSONSchema","schemaJson","JSON","stringify","isPrimitive","includes","type"],"mappings":"AAAA,SAASA,CAAC,QAAQ,SAAS;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,SAASC,mBAAsBC,MAAoB;IACtD,IAAMC,aAAaH,EAAEI,YAAY,CAACF;IAClC,IAAMG,aAAaC,KAAKC,SAAS,CAACJ,YAAY,MAAM;IAEpD,IAAMK,cAAc;QAAC;QAAW;QAAW;QAAU;KAAS,CAACC,QAAQ,CACnEN,WAAWO,IAAI;IAGnB,IAAIF,aAAa;QACb,OAAO,AAAC,4CAIdH,OAHwBF,WAAWO,IAAI,EAAC,iDAMPP,OAHjCE,YAAW,8CAGsC,OAAhBF,WAAWO,IAAI,EAAC;IAE/C;IAEA,OAAO,AAAC,gGAIC,OAAXL,YAAW;AAKb"}

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

@@ -0,0 +1,33 @@
+import { z } from 'zod/v4';
+/**
+ * Error thrown when object parsing fails.
+ * Contains the original text for debugging purposes.
+ */
+export declare class ParseObjectError extends Error {
+    readonly cause?: unknown | undefined;
+    readonly text?: string | undefined;
+    readonly name = "ParseObjectError";
+    constructor(message: string, cause?: unknown | undefined, text?: string | undefined);
+}
+/**
+ * Parses AI-generated text into structured data validated against a Zod schema.
+ *
+ * Handles common AI response formats:
+ * - JSON wrapped in markdown code blocks
+ * - JSON embedded in prose text
+ * - Malformed JSON (auto-repaired)
+ * - Escaped unicode and special characters
+ *
+ * @param text - The raw AI response text
+ * @param schema - A Zod schema to validate and type the result
+ * @returns The parsed and validated data
+ * @throws {ParseObjectError} When parsing or validation fails
+ *
+ * @example
+ * ```ts
+ * const schema = z.object({ title: z.string(), tags: z.array(z.string()) });
+ * const result = parseObject(aiResponse, schema);
+ * // result is typed as { title: string; tags: string[] }
+ * ```
+ */
+export declare function parseObject<T>(text: string, schema: z.ZodSchema<T>): T;

package/dist/parsing/parse-object.js

@@ -0,0 +1,360 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+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);
+}
+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;
+    })();
+}
+import { jsonrepair } from 'jsonrepair';
+import { z } from 'zod/v4';
+/**
+ * Error thrown when object parsing fails.
+ * Contains the original text for debugging purposes.
+ */ export var ParseObjectError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(ParseObjectError, Error1);
+    function ParseObjectError(message, cause, text) {
+        _class_call_check(this, ParseObjectError);
+        var _this;
+        _this = _call_super(this, ParseObjectError, [
+            message
+        ]), _define_property(_this, "cause", void 0), _define_property(_this, "text", void 0), _define_property(_this, "name", void 0), _this.cause = cause, _this.text = text, _this.name = 'ParseObjectError';
+        return _this;
+    }
+    return ParseObjectError;
+}(_wrap_native_super(Error));
+/**
+ * Parses AI-generated text into structured data validated against a Zod schema.
+ *
+ * Handles common AI response formats:
+ * - JSON wrapped in markdown code blocks
+ * - JSON embedded in prose text
+ * - Malformed JSON (auto-repaired)
+ * - Escaped unicode and special characters
+ *
+ * @param text - The raw AI response text
+ * @param schema - A Zod schema to validate and type the result
+ * @returns The parsed and validated data
+ * @throws {ParseObjectError} When parsing or validation fails
+ *
+ * @example
+ * ```ts
+ * const schema = z.object({ title: z.string(), tags: z.array(z.string()) });
+ * const result = parseObject(aiResponse, schema);
+ * // result is typed as { title: string; tags: string[] }
+ * ```
+ */ export function parseObject(text, schema) {
+    try {
+        var jsonString = extractJsonString(text);
+        var extracted = extractBySchemaType(jsonString, schema, text);
+        var unescaped = unescapeJsonValues(extracted);
+        return schema.parse(unescaped);
+    } catch (error) {
+        if (_instanceof(error, ParseObjectError)) {
+            throw error;
+        }
+        if (_instanceof(error, z.ZodError)) {
+            throw new ParseObjectError('Failed to validate response against schema', error, text);
+        }
+        throw error;
+    }
+}
+var MARKDOWN_CODE_BLOCK_RE = /```(?:json)?\r?\n([^`]*?)\r?\n```/g;
+function convertToPrimitive(value, schema) {
+    if (_instanceof(schema, z.ZodBoolean)) return Boolean(value);
+    if (_instanceof(schema, z.ZodNull)) return null;
+    if (_instanceof(schema, z.ZodNumber)) return Number(value);
+    if (_instanceof(schema, z.ZodString)) return String(value);
+    return value;
+}
+function extractArray(text, originalText) {
+    var start = text.indexOf('[');
+    var end = text.lastIndexOf(']');
+    if (start === -1 || end === -1) {
+        throw new ParseObjectError('No array found in response', undefined, originalText);
+    }
+    try {
+        var raw = text.slice(start, end + 1);
+        return JSON.parse(jsonrepair(raw));
+    } catch (error) {
+        throw new ParseObjectError('Failed to parse array JSON', error, originalText);
+    }
+}
+function extractBySchemaType(text, schema, originalText) {
+    if (_instanceof(schema, z.ZodArray)) {
+        return extractArray(text, originalText);
+    }
+    if (_instanceof(schema, z.ZodObject)) {
+        return extractObject(text, originalText);
+    }
+    if (_instanceof(schema, z.ZodBoolean) || _instanceof(schema, z.ZodNull) || _instanceof(schema, z.ZodNumber) || _instanceof(schema, z.ZodString)) {
+        return extractPrimitive(text, schema);
+    }
+    throw new ParseObjectError('Unsupported schema type', undefined, originalText);
+}
+function extractJsonFromCodeBlock(block) {
+    var content = block.replace(/```(?:json)?\r?\n([^`]*?)\r?\n```/, '$1').trim();
+    try {
+        JSON.parse(content);
+        return content;
+    } catch (e) {
+        return null;
+    }
+}
+function extractJsonString(text) {
+    var codeBlocks = text.match(MARKDOWN_CODE_BLOCK_RE);
+    if (codeBlocks && codeBlocks.length > 0) {
+        var validBlocks = codeBlocks.map(function(block) {
+            return extractJsonFromCodeBlock(block);
+        }).filter(function(block) {
+            return block !== null;
+        });
+        if (validBlocks.length > 0) {
+            return findLongestString(validBlocks);
+        }
+    }
+    var structures = findJsonStructures(text);
+    if (structures.length > 0) {
+        return findLongestString(structures);
+    }
+    return text.replace(/\s+/g, ' ').trim();
+}
+function extractObject(text, originalText) {
+    var start = text.indexOf('{');
+    var end = text.lastIndexOf('}');
+    if (start === -1 || end === -1) {
+        throw new ParseObjectError('No object found in response', undefined, originalText);
+    }
+    try {
+        var raw = text.slice(start, end + 1);
+        return JSON.parse(jsonrepair(raw));
+    } catch (error) {
+        throw new ParseObjectError('Failed to parse object JSON', error, originalText);
+    }
+}
+function extractPrimitive(text, schema) {
+    var trimmed = text.trim();
+    try {
+        return convertToPrimitive(JSON.parse(trimmed), schema);
+    } catch (e) {
+        return convertToPrimitive(trimmed, schema);
+    }
+}
+function findJsonStructures(text) {
+    var matches = [];
+    var depth = 0;
+    var start = -1;
+    for(var i = 0; i < text.length; i++){
+        var _char = text[i];
+        if (_char === '{' || _char === '[') {
+            if (depth === 0) start = i;
+            depth++;
+        } else if (_char === '}' || _char === ']') {
+            depth--;
+            if (depth === 0 && start !== -1) {
+                var candidate = text.slice(start, i + 1);
+                try {
+                    JSON.parse(candidate);
+                    matches.push(candidate);
+                } catch (e) {
+                // Invalid JSON, skip
+                }
+            }
+        }
+    }
+    return matches;
+}
+function findLongestString(strings) {
+    return strings.reduce(function(longest, current) {
+        return current.length > longest.length ? current : longest;
+    });
+}
+function unescapeJsonValues(json) {
+    if (typeof json === 'string') {
+        return unescapeString(json);
+    }
+    if (Array.isArray(json)) {
+        return json.map(unescapeJsonValues);
+    }
+    if ((typeof json === "undefined" ? "undefined" : _type_of(json)) === 'object' && json !== null) {
+        return Object.fromEntries(Object.entries(json).map(function(param) {
+            var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+            return [
+                key,
+                unescapeJsonValues(value)
+            ];
+        }));
+    }
+    return json;
+}
+function unescapeString(text) {
+    return text.replace(/\\"/g, '"').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(/\\t/g, '\t').replace(/\\\\/g, '\\').replace(/\\u([0-9a-fA-F]{4})/g, function(_, code) {
+        return String.fromCharCode(Number.parseInt(code, 16));
+    });
+}
+
+//# sourceMappingURL=parse-object.js.map