@tstdl/base 0.93.62 → 0.93.66

package/document-management/server/services/document-management-ai.service.js

@@ -58,9 +58,11 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 var _a;
 var DocumentManagementAiService_1;
+import { readFile } from 'node:fs/promises';
 import { and, isNull as drizzleIsNull, eq, inArray } from 'drizzle-orm';
 import { P, match } from 'ts-pattern';
-import { AiService } from '../../../ai/index.js';
+import { convertToGenkitSchema, genkitGenerationOptions, injectGenkit, injectModel } from '../../../ai/genkit/index.js';
+import { formatData, formatInstructions, orderedList } from '../../../ai/prompts/index.js';
 import { TemporaryFile } from '../../../file/server/index.js';
 import { inject } from '../../../injector/inject.js';
 import { Logger } from '../../../logger/logger.js';
@@ -68,7 +70,7 @@ import { arrayAgg } from '../../../orm/index.js';
 import { injectRepository } from '../../../orm/server/index.js';
 import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
 import { distinct } from '../../../utils/array/index.js';
-import { numericDateToDateObject, tryDateObjectToNumericDate } from '../../../utils/date-time.js';
+import { numericDateToDateTime, tryDateObjectToNumericDate } from '../../../utils/date-time.js';
 import { fromEntries, objectEntries } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, assertNotNull, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.js';
 import { Document, DocumentProperty, DocumentRequestState, DocumentTypeProperty } from '../../models/index.js';
@@ -79,78 +81,227 @@ import { DocumentFileService } from './document-file.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
 import { DocumentTagService } from './document-tag.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
-const CLASSIFY_MODEL = 'small';
-const EXTRACT_MODEL = 'medium';
-const ASSIGN_MODEL = 'small';
+// --- Prompts ---
+const ocrSystemPrompt = `
+You are an expert OCR and Document Digitization engine.
+
+${formatInstructions({
+    'Primary Objective': 'Convert the provided document into semantically structured, clean Markdown.',
+    'Critical Constraints': orderedList([
+        'Output ONLY the Markdown content. Do not include introductory text, conversational filler, or code block fences (```).',
+        'Do not describe the visual appearance (e.g., "This looks like an invoice"). Transcribe the content only.',
+    ]),
+    'Formatting Rules': orderedList({
+        'Headings': 'Use # for the main document title (once). Use ##, ### for sections based on logical hierarchy.',
+        'Text Content': 'Transcribe text verbatim. Do not correct spelling or grammar, summarize, or rewrite.',
+        'Tables': 'Strictly use Markdown table syntax. Align columns logically based on the visual grid.',
+        'Lists': 'Detect bullet points and numbered lists and format them as Markdown lists.',
+        'Emphasis': 'Use **bold** and _italics_ only where visually distinct in the source.',
+        'Columns': 'Read multi-column text as a single continuous flow.',
+    }),
+    'Complex Elements': {
+        'Images/Visuals': 'Replace non-textual diagrams with `> [Visual: Brief description of the image/chart]`.',
+        'Signatures': 'Mark distinct signatures as `> [Signature: {Name if legible/Context}]`.',
+        'Forms': 'Represent checkboxes as `[ ]` (unchecked) or `[x]` (checked). Format label/value pairs on separate lines or as a definition list if applicable.',
+        'Math': 'Transcribe equations using LaTeX syntax enclosed in `$...$` for inline or `$$...$$` for block equations.',
+    },
+    'Page Handling': [
+        'Metadata: Start every page with `<!-- Page {n} Start -->` and end with `<!-- Page {n} End -->` on separate lines.',
+        'Artifacts: Exclude running headers, footers, and page numbers unless they contain unique data not found elsewhere.',
+    ],
+    'Error Handling': [
+        'Mark illegible text as `[Illegible]`.',
+        'Mark cut-off text as `[Cut off]`.',
+    ],
+})}
+`.trim();
+const ocrUserPrompt = 'Transcribe the attached document into Markdown following the system instructions.';
+const classifySystemPrompt = `
+You are a Document Taxonomy Specialist.
+
+${formatInstructions({
+    'Task': `Analyze the visual layout and text content of the document to categorize it into exactly one of the provided hierarchical types.`,
+    'Input Context': 'You will be provided with a list of valid category labels (e.g., "Finance -> Invoice").',
+    'Analysis Strategy': orderedList([
+        'Scan the header and title for explicit document type names (e.g., "Invoice", "Contract", "Bill of Lading").',
+        'Analyze the layout structure (e.g., columns often imply Invoices/Receipts; dense paragraphs imply Contracts/Letters).',
+        'Identify key entities (e.g., "Total Due" implies financial; "Signed by" implies legal).',
+    ]),
+    'Selection Logic': orderedList([
+        'Exact Match: If the document explicitly states its type, select the corresponding category.',
+        'Content Match: If implicit, match the intent.',
+        'Specificity: Always choose the most specific leaf-node category available.',
+        'Fallback: If ambiguous, choose the category that best describes the *primary* purpose of the document.',
+    ]),
+})}
+`.trim();
+const classifyUserPrompt = 'Determine the single most accurate document type from the provided list based on the document following the system instructions.';
+const extractSystemPrompt = `
+You are a Structured Data Extraction Analyst.
+
+${formatInstructions({
+    'Task': 'Analyze the document and extract metadata into the defined JSON schema.',
+    'General Guidelines': orderedList({
+        'Language': 'Ensure all generated text (titles, summaries) matches the primary language of the document.',
+        'Null Handling': 'If a specific field or property is not present in the document, return null. Do not guess or hallucinate values.',
+    }),
+    'Field Specific Instructions': {
+        'Title': 'Create a concise, searchable filename-style title (e.g., "Invoice - Oct 2023").',
+        'Subtitle': 'Extract context usually found below the header (e.g., Project Name, Reference Number).',
+        'Summary': 'Write a 2-3 sentence executive summary. Mention the what type of information can be found in the document and its purpose.',
+        'Tags': 'Generate 3-5 keywords for categorization. Only use important information missing in title, subtitle and properties. Prioritize reusing of existing tags where possible.',
+        'Date': 'Identify the *creation* date of the document. If multiple dates exist, prioritize the primary date (like invoice or letter Date)',
+    },
+    'Property Extraction': [
+        'You will be given a list of specific dynamic properties to look for.',
+        'Extract values *exactly* as they appear for strings.',
+        'Normalize numbers and dates to standard formats.',
+        'If a property is ambiguous, favor the value most prominent in the document layout.',
+        'If a property is missing, set its value to null.',
+    ],
+})}`.trim();
+const extractUserPrompt = 'Analyze the document and extract metadata and specific properties defined in the output schema following the system instructions.';
+const assignCollectionSystemPrompt = `
+You are a Digital Filing Assistant.
+
+${formatInstructions({
+    'Task': `Assign the document to relevant collections based on its metadata and content.`,
+    'Input': 'Document Metadata and a list of Available Collections.',
+    'Matching Logic': orderedList([
+        'Direct Key-Match: Look for exact keyword matches between the collection name and the document metadata.',
+        'Semantic Fit: Determine if the document functionally belongs to a group.',
+        'Project Association: If the document references a specific project code or name found in a collection name, assign it there.',
+    ]),
+    'Output': 'Return an array of matching collection IDs. If no collection is a strong fit, return an empty array.',
+})}
+`.trim();
+const assignCollectionUserPrompt = 'Select the most appropriate collections for this document from the provided list following the system instructions.';
+const assignRequestSystemPrompt = `
+You are a Workflow Routing Agent.
+
+${formatInstructions({
+    'Task': 'Match the provided document to an existing Open Document Request.',
+    'Input': 'Document Metadata and a list of Open Requests.',
+    'Matching Rules': orderedList({
+        'Hard Constraints': 'If a Request has a "Comment" or specific property requirement, the document MUST fulfill it strictly (e.g., "Need bill from July" must match date).',
+        'Ambiguity': 'If multiple requests match, select the one with the most specific constraints that are satisfied.',
+        'Negative Match': 'If the document satisfies the metadata but violates a comment constraint, it is unsuitable.',
+    }),
+    'Output': 'The ID of the matching request, or null if no request matches.',
+})}
+`.trim();
+const assignRequestUserPrompt = 'Evaluate the document against the list of open requests and find the best match following the system instructions.';
 let DocumentManagementAiService = DocumentManagementAiService_1 = class DocumentManagementAiService {
+    #genkit = injectGenkit();
+    #ocrModel = injectModel('gemini-2.5-flash-lite').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
+    #classifyModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
+    #extractModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
+    #assignModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.25, topP: 0.75, topK: 8 });
     #documentCollectionService = inject(DocumentCollectionService);
     #documentTagService = inject(DocumentTagService);
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentFileService = inject(DocumentFileService);
     #documentPropertyService = inject(DocumentPropertyService);
-    #aiService = inject(AiService);
     #documentPropertyRepository = injectRepository(DocumentProperty);
     #documentRepository = injectRepository(Document);
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
     #logger = inject(Logger, DocumentManagementAiService_1.name);
-    async classifyDocumentType(tenantId, documentId) {
+    async extractDocumentContent(tenantId, documentId) {
         const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+            const fileContentStream = this.#documentFileService.getContentStream(document);
+            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
+            const buffer = await readFile(tmpFile.path);
+            const base64Data = buffer.toString('base64');
+            const dataUrl = `data:${document.mimeType};base64,${base64Data}`;
+            this.#logger.trace(`Extracting content from document ${document.id}`);
+            const result = await this.#genkit.generate({
+                model: this.#ocrModel,
+                output: { schema: convertToGenkitSchema(object({ content: string() })) },
+                system: ocrSystemPrompt,
+                prompt: [
+                    { media: { url: dataUrl } },
+                    { text: ocrUserPrompt },
+                ],
+            });
+            if (isNull(result.output)) {
+                throw new Error(`AI returned null output for document "${document.id}".`);
+            }
+            const markdownBlockStripped = result.output.content.trim().replaceAll(/^```\w*\s*|```$/gi, '').trim();
+            return markdownBlockStripped;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    async classifyDocumentType(tenantId, documentId) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
         try {
             const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
             if (isNotNull(document.typeId)) {
                 return document.typeId;
             }
             const fileContentStream = this.#documentFileService.getContentStream(document);
-            const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
-            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });
+            const tmpFile = __addDisposableResource(env_2, await TemporaryFile.from(fileContentStream), true);
+            const buffer = await readFile(tmpFile.path);
+            const base64Data = buffer.toString('base64');
+            const dataUrl = `data:${document.mimeType};base64,${base64Data}`;
             const categories = await this.#documentCategoryTypeService.loadCategoryViews(tenantId);
             const typeLabelEntries = getDescriptiveTypeLabels(categories);
             const typeLabels = typeLabelEntries.map(({ label }) => label);
             this.#logger.trace(`Classifying document ${document.id}`);
-            const documentTypeGeneration = await this.#aiService.generate({
-                model: CLASSIFY_MODEL,
-                generationOptions: {
+            const result = await this.#genkit.generate(genkitGenerationOptions({
+                model: this.#classifyModel,
+                config: {
                     maxOutputTokens: 128,
-                    temperature: 0.1,
-                    topP: 0.75,
-                    topK: 4,
-                    thinkingBudget: 0,
+                    thinkingConfig: { thinkingBudget: 0 },
                 },
-                generationSchema: object({
-                    documentType: enumeration(typeLabels),
-                }),
-                contents: [
-                    {
-                        role: 'user',
-                        parts: [
-                            { file: filePart.file },
-                            { text: `Klassifiziere den Inhalt des Dokuments in das angegebenen JSON Schema.` },
-                        ],
-                    },
+                output: {
+                    schema: object({
+                        documentType: enumeration(typeLabels),
+                    }),
+                },
+                system: classifySystemPrompt,
+                prompt: [
+                    { media: { url: dataUrl } },
+                    { text: classifyUserPrompt },
                 ],
-            });
-            const typeId = typeLabelEntries.find((entry) => entry.label == documentTypeGeneration.json.documentType)?.id;
+            }));
+            if (isNull(result.output)) {
+                throw new Error(`AI returned null output for document classification "${document.id}".`);
+            }
+            const output = result.output;
+            const typeId = typeLabelEntries.find((entry) => entry.label == output.documentType)?.id;
             assertDefined(typeId, `Could not classify document ${document.id}`);
             return typeId;
         }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
         }
         finally {
-            const result_1 = __disposeResources(env_1);
-            if (result_1)
-                await result_1;
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
         }
     }
     async extractDocumentInformation(tenantId, documentId) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
+        const env_3 = { stack: [], error: void 0, hasError: false };
         try {
             const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
             const existingTags = await this.#documentTagService.loadTags(tenantId);
             const fileContentStream = this.#documentFileService.getContentStream(document);
-            const tmpFile = __addDisposableResource(env_2, await TemporaryFile.from(fileContentStream), true);
-            const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });
+            const tmpFile = __addDisposableResource(env_3, await TemporaryFile.from(fileContentStream), true);
+            const buffer = await readFile(tmpFile.path);
+            const base64Data = buffer.toString('base64');
+            const dataUrl = `data:${document.mimeType};base64,${base64Data}`;
             if (isNull(document.typeId)) {
                 throw new Error(`Document ${document.id} has no type`);
             }
@@ -177,39 +328,31 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
                     ? {}
                     : { documentProperties: object(fromEntries(propertiesSchemaEntries)) }),
             });
-            const context = { existingTags };
+            const tagLabels = existingTags.map((tag) => tag.label);
             this.#logger.trace(`Extracting document ${document.id}`);
-            const { json: extraction } = await this.#aiService.generate({
-                model: EXTRACT_MODEL,
-                generationOptions: {
+            const result = await this.#genkit.generate(genkitGenerationOptions({
+                model: this.#extractModel,
+                output: { schema: generationSchema },
+                config: {
                     maxOutputTokens: 2048,
-                    temperature: 0.2,
-                    topP: 0.5,
-                    topK: 16,
-                    thinkingBudget: 0,
+                    thinkingConfig: { thinkingBudget: 0 },
                 },
-                generationSchema,
-                contents: [
+                system: extractSystemPrompt,
+                prompt: [
+                    { media: { url: dataUrl } },
                     {
-                        role: 'user',
-                        parts: [
-                            { file: filePart.file },
-                            {
-                                text: `<context>
-${JSON.stringify(context, null, 2)}
-</context>
-              Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
+                        text: `
+${formatData({ existingTags: tagLabels })}
 
-Vermeide es, den Titel im Untertitel zu wiederholen.
-Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen (ohne konkrete Werte).
-Erstelle bis zu 5 Tags. Verwende vorhandene Tags, wenn sie passen. Erstelle neue Tags, wenn es keine passenden gibt.
-Vermeide es, den Titel oder Untertitel als Tag zu verwenden.
-Antworte auf deutsch.`,
-                            },
-                        ],
+${extractUserPrompt}
+`.trim(),
                     },
                 ],
-            });
+            }));
+            if (isNull(result.output)) {
+                throw new Error(`AI returned null output for document extraction "${document.id}".`);
+            }
+            const extraction = result.output;
             const filteredDocumentTags = extraction.documentTags.filter((tag) => (tag != extraction.documentTitle) && (tag != extraction.documentSubtitle));
             const date = isNotNull(extraction.documentDate) ? tryAiOutputDateObjectToNumericDate(extraction.documentDate) : null;
             const parsedProperties = isUndefined(extraction.documentProperties)
@@ -238,14 +381,14 @@ Antworte auf deutsch.`,
                 properties: parsedProperties,
             };
         }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
+        catch (e_3) {
+            env_3.error = e_3;
+            env_3.hasError = true;
         }
         finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
+            const result_3 = __disposeResources(env_3);
+            if (result_3)
+                await result_3;
         }
     }
     async findSuitableCollectionsForDocument(document, collectionIds) {
@@ -261,41 +404,36 @@ Antworte auf deutsch.`,
         }));
         const documentTagLabels = documentTags.map((tag) => tag.label);
         const propertyEntries = documentProperties.map((property) => [property.label, property.value]);
-        const context = {
-            document: {
-                title: document.title ?? undefined,
-                subtitle: document.subtitle ?? undefined,
-                date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
-                summary: document.summary ?? undefined,
-                tags: (documentTagLabels.length > 0) ? documentTagLabels : undefined,
-                properties: fromEntries(propertyEntries),
-            },
-            collections,
+        const documentData = {
+            title: document.title ?? null,
+            subtitle: document.subtitle ?? null,
+            date: isNotNull(document.date) ? numericDateToDateTime(document.date).toISODate() : null,
+            tags: (documentTagLabels.length > 0) ? documentTagLabels : null,
+            summary: document.summary ?? null,
         };
-        const result = await this.#aiService.generate({
-            model: ASSIGN_MODEL,
-            generationOptions: {
-                maxOutputTokens: 100,
-                temperature: 0,
-                topP: 0.2,
-                topK: 16,
-                thinkingBudget: 0,
+        const result = await this.#genkit.generate(genkitGenerationOptions({
+            model: this.#assignModel,
+            output: { schema: object({ collectionIds: array(string()) }) },
+            config: {
+                maxOutputTokens: 512,
+                thinkingConfig: {
+                    thinkingBudget: 0,
+                },
             },
-            generationSchema: object({ collectionIds: array(string()) }),
-            contents: [{
-                    role: 'user',
-                    parts: [
-                        {
-                            text: `<context>
-${JSON.stringify(context, null, 2)}
-</context>
+            system: assignCollectionSystemPrompt,
+            prompt: [{
+                    text: `
+${formatData({ document: documentData, documentProperties: fromEntries(propertyEntries) })}
+
+${formatData({ collections })}
 
-Ordne das Dokument unter "document" einer oder mehreren passenden Collection unter "collections" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Collection passt, gib collectionIds als leeres Array zurück.`,
-                        },
-                    ],
+${assignCollectionUserPrompt}`,
                 }],
-        });
-        return result.json.collectionIds;
+        }));
+        if (isNull(result.output)) {
+            throw new Error(`AI returned null output for collection assignment "${document.id}".`);
+        }
+        return result.output.collectionIds;
     }
     async findSuitableRequestForDocument(document, collectionIds) {
         const session = this.#documentPropertyRepository.session;
@@ -322,44 +460,40 @@ Ordne das Dokument unter "document" einer oder mehreren passenden Collection unt
         const requests = openRequestsWithoutDocument.map((request) => ({
             id: request.id,
             collections: request.collectionIds.map((collectionId) => assertDefinedPass(collectionNamesMap[collectionId]).name),
-            comment: request.comment ?? undefined,
+            comment: request.comment ?? null,
         }));
         const propertyEntries = documentProperties.map((property) => [property.label, property.value]);
-        const context = {
-            document: {
-                title: document.title ?? undefined,
-                subtitle: document.subtitle ?? undefined,
-                date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
-                summary: document.summary ?? undefined,
-                tags: (documentTagLabels.length > 0) ? documentTagLabels : undefined,
-                properties: fromEntries(propertyEntries),
-            },
-            requests,
+        const documentData = {
+            title: document.title ?? null,
+            subtitle: document.subtitle ?? null,
+            date: isNotNull(document.date) ? numericDateToDateTime(document.date).toISODate() : null,
+            tags: (documentTagLabels.length > 0) ? documentTagLabels : null,
+            summary: document.summary ?? null,
         };
-        const result = await this.#aiService.generate({
-            model: ASSIGN_MODEL,
-            generationOptions: {
-                maxOutputTokens: 100,
-                temperature: 0,
-                topP: 0.2,
-                topK: 16,
-                thinkingBudget: 0,
+        const result = await this.#genkit.generate(genkitGenerationOptions({
+            model: this.#assignModel,
+            config: {
+                maxOutputTokens: 128,
+                thinkingConfig: {
+                    thinkingBudget: 0,
+                },
             },
-            generationSchema: object({ requestId: nullable(string()) }),
-            contents: [{
-                    role: 'user',
-                    parts: [
-                        {
-                            text: `<context>
-${JSON.stringify(context, null, 2)}
-</context>
+            output: { schema: object({ requestId: nullable(string()) }) },
+            system: assignRequestSystemPrompt,
+            prompt: [{
+                    text: `
+${formatData({ document: documentData, documentProperties: fromEntries(propertyEntries) })}
+
+${formatData({ requests })}
 
-Ordne das Dokument unter "document" der passenden Anforderungen unter "requests" zu. Gib es als JSON im angegebenen Schema aus. Wenn keine Anforderung passt, setze requestId auf null.`,
-                        },
-                    ],
+${assignRequestUserPrompt}
+`.trim(),
                 }],
-        });
-        return result.json.requestId;
+        }));
+        if (isNull(result.output)) {
+            throw new Error(`AI returned null output for request assignment "${document.id}".`);
+        }
+        return result.output.requestId;
     }
 };
 DocumentManagementAiService = DocumentManagementAiService_1 = __decorate([

package/document-management/server/services/document.service.js

@@ -17,7 +17,7 @@ import { objectKeys } from '../../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../../utils/stream/from-promise.js';
 import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
 import { isDefined, isNotReadableStream, isNotUint8Array, isUndefined } from '../../../utils/type-guards.js';
-import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentType, DocumentWorkflowStep } from '../../models/index.js';
+import { Document, DocumentApproval, DocumentAssignmentScope, DocumentAssignmentTask, DocumentWorkflowStep } from '../../models/index.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentFileService } from './document-file.service.js';
 import { DocumentManagementObservationService } from './document-management-observation.service.js';
@@ -33,7 +33,6 @@ let DocumentService = DocumentService_1 = class DocumentService extends Transact
     #workflowService = injectTransactional(DocumentWorkflowService);
     #documentPropertyService = injectTransactional(DocumentPropertyService);
     #collectionService = injectTransactional(DocumentCollectionService);
-    #documentTypeRepository = injectRepository(DocumentType);
     #documentAssignmentTaskRepository = injectRepository(DocumentAssignmentTask);
     #documentAssignmentScopeRepository = injectRepository(DocumentAssignmentScope);
     #observationService = inject(DocumentManagementObservationService);

package/examples/document-management/main.js

@@ -5,6 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import '../../polyfills.js';
+import { configureGenkit } from '../../ai/genkit/module.js';
 import { configureAiService } from '../../ai/index.js';
 import { MockApiRequestTokenProvider } from '../../api/server/api-request-token.provider.js';
 import { configureApiServer } from '../../api/server/module.js';
@@ -88,6 +89,11 @@ async function bootstrap() {
     configurePostgresQueue();
     configureLocalMessageBus();
     configureDefaultSignalsImplementation();
+    configureGenkit({
+        gemini: {
+            apiKey: config.ai.apiKey,
+        },
+    });
     configureOrm({
         connection: {
             host: config.database.host,

package/json-path/json-path.js

@@ -1,7 +1,7 @@
 import { isIterable } from '../utils/iterable-helpers/is-iterable.js';
 import { assertDefinedPass, isArray, isDefined, isString, isSymbol, isUndefined } from '../utils/type-guards.js';
 const numberPattern = /^\d+$/u;
-const parsePattern = /(?:(?:^|\.)(?<dot>[^.[]+))|(?<root>^\$)|\[(?:(?:'(?<bracket>.+?)')|(?<index>\d+)|(?:Symbol\((?<symbol>.*)\)))\]|(?<error>.+?)/ug;
+const parsePattern = /(?:(?:^|\.)(?<dot>[^.[]+))|(?<root>^\$)|\[(?:(?:['"](?<bracket>.+?)['"])|(?<index>\d+)|(?:Symbol\((?<symbol>.*)\)))\]|(?<error>.+?)/ug;
 export class JsonPath {
     _options;
     _path;

package/orm/server/repository.js

@@ -11,12 +11,11 @@ import { NotFoundError } from '../../errors/not-found.error.js';
 import { Singleton } from '../../injector/decorators.js';
 import { inject, injectArgument } from '../../injector/inject.js';
 import { afterResolve, resolveArgumentType } from '../../injector/interfaces.js';
-import { Schema } from '../../schema/schema.js';
 import { distinct, toArray } from '../../utils/array/array.js';
 import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { importSymmetricKey } from '../../utils/cryptography.js';
-import { fromDeepObjectEntries, fromEntries, objectEntries } from '../../utils/object/object.js';
+import { assignDeep, fromEntries, objectEntries } from '../../utils/object/object.js';
 import { toSnakeCase } from '../../utils/string/index.js';
 import { cancelableTimeout } from '../../utils/timing.js';
 import { tryIgnoreAsync } from '../../utils/try-ignore.js';
@@ -1073,14 +1072,13 @@ let EntityRepository = class EntityRepository extends Transactional {
         return await toArrayAsync(mapAsync(columns, async (column) => await this._mapToEntity(column, transformContext)));
     }
     async _mapToEntity(columns, transformContext) {
-        const entries = [];
+        const entity = new this.type();
         for (const def of this.#columnDefinitions) {
             const rawValue = columns[def.name];
             const transformed = await def.fromDatabase(rawValue, transformContext);
-            entries.push([def.objectPath, transformed]); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+            assignDeep(entity, def.objectPath, transformed);
         }
-        const obj = fromDeepObjectEntries(entries);
-        return Schema.parse(this.type, obj);
+        return entity;
     }
     async _mapManyToColumns(objects, transformContext) {
         return await toArrayAsync(mapAsync(objects, async (obj) => await this._mapToColumns(obj, transformContext)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.62",
+  "version": "0.93.66",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -37,6 +37,7 @@
     "./supports": "./supports.js",
     "./tokens": "./tokens.js",
     "./ai": "./ai/index.js",
+    "./ai/genkit": "./ai/genkit/index.js",
     "./api": "./api/index.js",
     "./api/client": "./api/client/index.js",
     "./api/server": "./api/server/index.js",
@@ -138,18 +139,21 @@
     "type-fest": "^5.3"
   },
   "peerDependencies": {
+    "@genkit-ai/google-genai": "^1.25",
     "@google-cloud/storage": "^7.18",
-    "@google/genai": "^1.31",
+    "@google/genai": "^1.32",
+    "@toon-format/toon": "^2.1.0",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
-    "drizzle-orm": "^0.44",
+    "drizzle-orm": "^0.45",
     "file-type": "^21.1",
+    "genkit": "^1.25",
     "handlebars": "^4.7",
     "minio": "^8.0",
-    "mjml": "^4.17",
+    "mjml": "^4.18",
     "nodemailer": "^7.0",
     "pg": "^8.16",
     "playwright": "^1.57",
@@ -158,7 +162,7 @@
     "sharp": "^0.34",
     "undici": "^7.16",
     "urlpattern-polyfill": "^10.1",
-    "zod": "^4.1"
+    "zod": "^3.25"
   },
   "peerDependenciesMeta": {
     "@tstdl/angular": {
@@ -182,7 +186,7 @@
     "typedoc-plugin-markdown": "4.9",
     "typedoc-plugin-missing-exports": "4.1",
     "typescript": "5.9",
-    "typescript-eslint": "8.48"
+    "typescript-eslint": "8.49"
   },
   "overrides": {
     "drizzle-kit": {