@tstdl/base 0.93.125 → 0.93.127

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

@@ -4,66 +4,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
 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 { 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 { genkitGenerationOptions, injectGenkit, injectModel } from '../../../ai/genkit/index.js';
+import { buildPrompts, jsonOutputInstructions, orderedList } from '../../../ai/prompts/index.js';
 import { inject } from '../../../injector/inject.js';
 import { Logger } from '../../../logger/logger.js';
 import { arrayAgg } from '../../../orm/index.js';
@@ -71,21 +17,21 @@ 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 { 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';
+import { fromEntries, hasOwnProperty, objectEntries, objectKeys } from '../../../utils/object/object.js';
+import { assertDefined, assertDefinedPass, assertNotNull, isDefined, isNotNull, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { Document, DocumentProperty, DocumentRequestState, DocumentType, DocumentTypeProperty, DocumentWorkflowStep } from '../../models/index.js';
+import { DocumentManagementConfiguration } from '../module.js';
 import { documentCategory, documentRequest, documentRequestCollectionAssignment, documentType } from '../schemas.js';
 import { DocumentCategoryTypeService } from './document-category-type.service.js';
 import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentFileService } from './document-file.service.js';
+import { DocumentManagementAiProviderService } from './document-management-ai-provider.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
 import { DocumentTagService } from './document-tag.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
-// --- Prompts ---
-const ocrSystemPrompt = `
-You are an expert OCR and Document Digitization engine.
-
-${formatInstructions({
+// --- Instructions ---
+const contentExtractionSystemInstructions = {
+    'Role': 'You are an expert OCR and Document Digitization engine.',
     '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 (```).',
@@ -113,13 +59,10 @@ ${formatInstructions({
         '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({
+};
+const contentExtractionUserInstructions = { Task: 'Transcribe the attached document into Markdown following the system instructions.' };
+const classifySystemInstructions = {
+    'Role': 'You are a Document Taxonomy Specialist.',
     '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([
@@ -133,24 +76,18 @@ ${formatInstructions({
         '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({
+    ...jsonOutputInstructions,
+};
+const classifyUserInstructions = { Task: 'Determine the single most accurate document type from the provided list based on the document following the system instructions.' };
+const dataExtractionInstructionsRaw = {
+    'Role': 'You are a Structured Data Extraction Analyst.',
     '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)',
+        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 type of information that 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). Return as object with year, month and day.',
     },
     'Property Extraction': [
         'You will be given a list of specific dynamic properties to look for.',
@@ -159,12 +96,12 @@ ${formatInstructions({
         '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({
+    ...jsonOutputInstructions,
+};
+const dataExtractionSystemInstructions = dataExtractionInstructionsRaw;
+const dataExtractionUserInstructions = { Task: 'Analyze the document and extract metadata and specific properties defined in the output schema following the system instructions.' };
+const assignCollectionSystemInstructions = {
+    'Role': 'You are a Digital Filing Assistant.',
     '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([
@@ -173,13 +110,10 @@ ${formatInstructions({
         '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({
+};
+const assignCollectionUserInstructions = { Task: 'Select the most appropriate collections for this document from the provided list following the system instructions.' };
+const assignRequestSystemInstructions = {
+    'Role': 'You are a Workflow Routing Agent.',
     'Task': 'Match the provided document to an existing Open Document Request.',
     'Input': 'Document Metadata and a list of Open Requests.',
     'Matching Rules': orderedList({
@@ -188,208 +122,161 @@ ${formatInstructions({
         '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.';
+};
+const assignRequestUserInstructions = { Task: '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 });
+    #contentExtractionModel = injectModel('gemini-2.5-flash-lite').withConfig({ temperature: 0.1, topP: 0.75, topK: 8 });
+    #classifyModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.1, topP: 0.75, topK: 8, thinkingConfig: { thinkingBudget: 0 } });
+    #dataExtractionModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.1, topP: 0.75, topK: 8, thinkingConfig: { thinkingBudget: 0 } });
+    #assignModel = injectModel('gemini-2.5-flash').withConfig({ temperature: 0.1, topP: 0.75, topK: 8, thinkingConfig: { thinkingBudget: 0 } });
     #documentCollectionService = inject(DocumentCollectionService);
     #documentTagService = inject(DocumentTagService);
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentFileService = inject(DocumentFileService);
     #documentPropertyService = inject(DocumentPropertyService);
+    #documentManagementConfiguration = inject(DocumentManagementConfiguration, undefined, { optional: true });
+    #aiProvider = inject(DocumentManagementAiProviderService, undefined, { optional: true });
     #documentPropertyRepository = injectRepository(DocumentProperty);
     #documentRepository = injectRepository(Document);
+    #documentTypeRepository = injectRepository(DocumentType);
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
     #logger = inject(Logger, DocumentManagementAiService_1.name);
-    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 extractContent(tenantId, documentId) {
+        const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+        this.#logger.trace(`Extracting content from document ${document.id}`);
+        const result = await this.runAi(tenantId, DocumentWorkflowStep.ContentExtraction, { document }, {
+            defaultModel: this.#contentExtractionModel,
+            system: contentExtractionSystemInstructions,
+            user: contentExtractionUserInstructions,
+            schema: object({ content: string() }),
+            document,
+        });
+        const markdownBlockStripped = result.content.trim().replaceAll(/^```\w*\s*|```$/gi, '').trim();
+        return markdownBlockStripped;
     }
     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_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 result = await this.#genkit.generate(genkitGenerationOptions({
-                model: this.#classifyModel,
-                config: {
-                    maxOutputTokens: 128,
-                    thinkingConfig: { thinkingBudget: 0 },
-                },
-                output: {
-                    schema: object({
-                        documentType: enumeration(typeLabels),
-                    }),
-                },
-                system: classifySystemPrompt,
-                prompt: [
-                    { media: { url: dataUrl } },
-                    { text: classifyUserPrompt },
-                ],
-            }));
-            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;
+        const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+        if (isNotNull(document.typeId)) {
+            return document.typeId;
         }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            const result_2 = __disposeResources(env_2);
-            if (result_2)
-                await result_2;
-        }
-    }
-    async extractDocumentInformation(tenantId, documentId) {
-        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_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`);
-            }
-            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId, typeId: document.typeId });
-            const propertyIds = typeProperties.map((property) => property.propertyId);
-            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ tenantId, id: { $in: propertyIds } }) : undefined;
-            const propertiesSchemaEntries = properties?.map((property) => {
-                const schema = match(property.dataType)
-                    .with('text', () => nullable(string()))
-                    .with('integer', () => nullable(integer()))
-                    .with('decimal', () => nullable(number()))
-                    .with('boolean', () => nullable(boolean()))
-                    .with('date', () => nullable(object({ year: integer(), month: integer(), day: integer() })))
-                    .exhaustive();
-                return [property.label, schema];
-            });
-            const generationSchema = object({
-                documentTitle: string(),
-                documentSubtitle: nullable(string()),
-                documentSummary: string(),
-                documentTags: array(string()),
-                documentDate: nullable(object({ year: integer(), month: integer(), day: integer() })),
-                ...((isUndefined(propertiesSchemaEntries) || (propertiesSchemaEntries.length == 0))
-                    ? {}
-                    : { documentProperties: object(fromEntries(propertiesSchemaEntries)) }),
-            });
-            const tagLabels = existingTags.map((tag) => tag.label);
-            this.#logger.trace(`Extracting document ${document.id}`);
-            const result = await this.#genkit.generate(genkitGenerationOptions({
-                model: this.#extractModel,
-                output: { schema: generationSchema },
-                config: {
-                    maxOutputTokens: 2048,
-                    thinkingConfig: { thinkingBudget: 0 },
-                },
-                system: extractSystemPrompt,
-                prompt: [
-                    { media: { url: dataUrl } },
-                    {
-                        text: `
-${formatData({ existingTags: tagLabels })}
-
-${extractUserPrompt}
-`.trim(),
-                    },
-                ],
-            }));
-            if (isNull(result.output)) {
-                throw new Error(`AI returned null output for document extraction "${document.id}".`);
+        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 stepData = { document, categories };
+        const aiConfig = await this.resolveAiConfiguration(tenantId, DocumentWorkflowStep.Classification, stepData);
+        const systemInstructions = isDefined(aiConfig.classification)
+            ? {
+                ...classifySystemInstructions,
+                'Classification Overrides': mergeInstructions('Follow these additional classification rules.', [aiConfig.classification]),
             }
-            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)
-                ? []
-                : objectEntries(extraction.documentProperties)
-                    .map(([propertyLabel, rawValue]) => {
-                    if (isNull(rawValue)) {
-                        return null;
-                    }
-                    const property = assertDefinedPass(properties?.find((property) => property.label == propertyLabel));
-                    const value = match(rawValue)
-                        .with({ year: P.number }, (value) => tryAiOutputDateObjectToNumericDate(value))
-                        .otherwise((value) => value);
-                    if (isNull(value)) {
-                        return null;
-                    }
-                    return { propertyId: property.id, dataType: property.dataType, value };
-                })
-                    .filter(isNotNull);
-            return {
-                title: extraction.documentTitle,
-                subtitle: extraction.documentSubtitle,
-                date,
-                summary: extraction.documentSummary,
-                tags: filteredDocumentTags,
-                properties: parsedProperties,
-            };
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            const result_3 = __disposeResources(env_3);
-            if (result_3)
-                await result_3;
+            : classifySystemInstructions;
+        const result = await this.runAi(tenantId, DocumentWorkflowStep.Classification, stepData, {
+            defaultModel: this.#classifyModel,
+            system: systemInstructions,
+            user: classifyUserInstructions,
+            schema: object({
+                documentType: enumeration(typeLabels),
+            }),
+            document,
+            config: { maxOutputTokens: 128 },
+            aiConfig,
+        });
+        const typeId = typeLabelEntries.find((entry) => entry.label == result.documentType)?.id;
+        assertDefined(typeId, `Could not classify document ${document.id}`);
+        return typeId;
+    }
+    async extractData(tenantId, documentId) {
+        const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+        const existingTags = await this.#documentTagService.loadTags(tenantId);
+        if (isNull(document.typeId)) {
+            throw new Error(`Document ${document.id} has no type`);
         }
+        const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId, typeId: document.typeId });
+        const propertyIds = typeProperties.map((property) => property.propertyId);
+        const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ tenantId, id: { $in: propertyIds } }) : undefined;
+        const propertiesSchemaEntries = properties?.map((property) => {
+            const schema = match(property.dataType)
+                .with('text', () => nullable(string()))
+                .with('integer', () => nullable(integer()))
+                .with('decimal', () => nullable(number()))
+                .with('boolean', () => nullable(boolean()))
+                .with('date', () => nullable(object({ year: integer(), month: integer(), day: integer() })))
+                .exhaustive();
+            return [property.label, schema];
+        });
+        const generationSchema = object({
+            documentTitle: string(),
+            documentSubtitle: nullable(string()),
+            documentSummary: string(),
+            documentTags: array(string()),
+            documentDate: nullable(object({ year: integer(), month: integer(), day: integer() })),
+            ...((isUndefined(propertiesSchemaEntries) || (propertiesSchemaEntries.length == 0))
+                ? {}
+                : { documentProperties: object(fromEntries(propertiesSchemaEntries)) }),
+        });
+        const tagLabels = existingTags.map((tag) => tag.label);
+        this.#logger.trace(`Extracting document ${document.id}`);
+        const documentTypeEntity = await this.#documentTypeRepository.load(document.typeId);
+        const stepData = { document, type: documentTypeEntity, properties };
+        const aiConfig = await this.resolveAiConfiguration(tenantId, DocumentWorkflowStep.DataExtraction, stepData);
+        const mergedFieldInstructions = {
+            Title: mergeFieldInstructions('Title', 'title', aiConfig),
+            Subtitle: mergeFieldInstructions('Subtitle', 'subtitle', aiConfig),
+            Date: mergeFieldInstructions('Date', 'date', aiConfig),
+            Summary: mergeFieldInstructions('Summary', 'summary', aiConfig),
+            Tags: mergeFieldInstructions('Tags', 'tags', aiConfig),
+        };
+        const mergedPropertyInstructions = properties?.map((property) => {
+            const override = (isNotNull(property.key) ? aiConfig.extraction?.properties?.[property.key] : undefined) ?? aiConfig.extraction?.properties?.[property.label];
+            return isDefined(override) ? mergeInstructions(`Extract value for property "${property.label}".`, [override]) : undefined;
+        }).filter(isDefined);
+        const systemInstructions = {
+            ...dataExtractionSystemInstructions,
+            'Field Specific Instructions': mergedFieldInstructions,
+            'Property Extraction': isDefined(mergedPropertyInstructions) && (mergedPropertyInstructions.length > 0)
+                ? [...dataExtractionInstructionsRaw['Property Extraction'], ...mergedPropertyInstructions]
+                : dataExtractionInstructionsRaw['Property Extraction'],
+        };
+        const extraction = await this.runAi(tenantId, DocumentWorkflowStep.DataExtraction, stepData, {
+            targetId: documentTypeEntity.key ?? undefined,
+            defaultModel: this.#dataExtractionModel,
+            system: systemInstructions,
+            user: dataExtractionUserInstructions,
+            data: { existingTags: tagLabels },
+            schema: generationSchema,
+            document,
+            config: { maxOutputTokens: 2048 },
+            aiConfig,
+        });
+        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)
+            ? []
+            : objectEntries(extraction.documentProperties)
+                .map(([propertyLabel, rawValue]) => {
+                if (isNull(rawValue)) {
+                    return null;
+                }
+                const property = assertDefinedPass(properties?.find((property) => property.label == propertyLabel));
+                const value = match(rawValue)
+                    .with({ year: P.number }, (value) => tryAiOutputDateObjectToNumericDate(value))
+                    .otherwise((value) => value);
+                if (isNull(value)) {
+                    return null;
+                }
+                return { propertyId: property.id, dataType: property.dataType, value };
+            })
+                .filter(isNotNull);
+        return {
+            title: extraction.documentTitle,
+            subtitle: extraction.documentSubtitle,
+            date,
+            summary: extraction.documentSummary,
+            tags: filteredDocumentTags,
+            properties: parsedProperties,
+        };
     }
     async findSuitableCollectionsForDocument(document, collectionIds) {
         assertNotNull(document.typeId, 'Document has no type');
@@ -411,29 +298,17 @@ ${extractUserPrompt}
             tags: (documentTagLabels.length > 0) ? documentTagLabels : null,
             summary: document.summary ?? null,
         };
-        const result = await this.#genkit.generate(genkitGenerationOptions({
-            model: this.#assignModel,
-            output: { schema: object({ collectionIds: array(string()) }) },
-            config: {
-                maxOutputTokens: 512,
-                thinkingConfig: {
-                    thinkingBudget: 0,
-                },
-            },
-            system: assignCollectionSystemPrompt,
-            prompt: [{
-                    text: `
-${formatData({ document: documentData, documentProperties: fromEntries(propertyEntries) })}
-
-${formatData({ collections })}
-
-${assignCollectionUserPrompt}`,
-                }],
-        }));
-        if (isNull(result.output)) {
-            throw new Error(`AI returned null output for collection assignment "${document.id}".`);
-        }
-        return result.output.collectionIds;
+        const documentTypeEntity = await this.#documentTypeRepository.load(document.typeId);
+        const result = await this.runAi(document.tenantId, DocumentWorkflowStep.Assignment, { document, properties: documentProperties, collectionIds }, {
+            targetId: documentTypeEntity.key ?? undefined,
+            defaultModel: this.#assignModel,
+            system: assignCollectionSystemInstructions,
+            user: assignCollectionUserInstructions,
+            data: { document: documentData, documentProperties: fromEntries(propertyEntries), collections },
+            schema: object({ collectionIds: array(string()) }),
+            config: { maxOutputTokens: 512 },
+        });
+        return result.collectionIds;
     }
     async findSuitableRequestForDocument(document, collectionIds) {
         const session = this.#documentPropertyRepository.session;
@@ -470,30 +345,119 @@ ${assignCollectionUserPrompt}`,
             tags: (documentTagLabels.length > 0) ? documentTagLabels : null,
             summary: document.summary ?? null,
         };
+        const documentTypeEntity = await this.#documentTypeRepository.load(document.typeId);
+        const result = await this.runAi(document.tenantId, DocumentWorkflowStep.Assignment, { document, properties: documentProperties, collectionIds: requestsCollectionIds }, {
+            targetId: documentTypeEntity.key ?? undefined,
+            defaultModel: this.#assignModel,
+            system: assignRequestSystemInstructions,
+            user: assignRequestUserInstructions,
+            data: { document: documentData, documentProperties: fromEntries(propertyEntries), requests },
+            schema: object({ requestId: nullable(string()) }),
+            config: { maxOutputTokens: 128 },
+        });
+        return result.requestId;
+    }
+    async runAi(tenantId, step, stepData, options) {
+        const config = options.aiConfig ?? await this.resolveAiConfiguration(tenantId, step, stepData);
+        const model = config.model ?? options.defaultModel;
+        const { systemPrompt, userPrompt } = buildPrompts({
+            baseSystemInstructions: options.system,
+            baseUserInstructions: options.user,
+            additionalSystemInstructions: config.prompt?.systemAddition,
+            additionalUserInstructions: config.prompt?.userAddition,
+            systemInstructionsOverride: config.prompt?.systemOverride,
+            userInstructionsOverride: config.prompt?.userOverride,
+            data: options.data,
+            media: isDefined(options.document) ? { mimeType: options.document.mimeType, content: await this.#documentFileService.getContent(options.document) } : undefined,
+            language: config.language,
+        });
         const result = await this.#genkit.generate(genkitGenerationOptions({
-            model: this.#assignModel,
-            config: {
-                maxOutputTokens: 128,
-                thinkingConfig: {
-                    thinkingBudget: 0,
-                },
-            },
-            output: { schema: object({ requestId: nullable(string()) }) },
-            system: assignRequestSystemPrompt,
-            prompt: [{
-                    text: `
-${formatData({ document: documentData, documentProperties: fromEntries(propertyEntries) })}
-
-${formatData({ requests })}
-
-${assignRequestUserPrompt}
-`.trim(),
-                }],
+            model,
+            config: options.config,
+            output: { schema: options.schema },
+            system: systemPrompt,
+            prompt: userPrompt,
         }));
         if (isNull(result.output)) {
-            throw new Error(`AI returned null output for request assignment "${document.id}".`);
+            throw new Error(`AI returned null output for ${step} ${options.targetId ?? ''}`);
         }
-        return result.output.requestId;
+        return result.output;
+    }
+    async resolveAiConfiguration(tenantId, step, data) {
+        const globalConfig = await this.#aiProvider?.getGlobalConfiguration(tenantId);
+        const { typeKey, categoryKey } = await this.resolveContextKeys(tenantId, data);
+        const stepConfig = await match(step)
+            .with(DocumentWorkflowStep.ContentExtraction, async () => await this.#aiProvider?.getContentExtractionConfiguration(tenantId, data))
+            .with(DocumentWorkflowStep.Classification, async () => await this.#aiProvider?.getClassificationConfiguration(tenantId, data))
+            .with(DocumentWorkflowStep.DataExtraction, async () => await this.#aiProvider?.getDataExtractionConfiguration(tenantId, data))
+            .with(DocumentWorkflowStep.Assignment, async () => await this.#aiProvider?.getAssignmentConfiguration(tenantId, data))
+            .with(DocumentWorkflowStep.Validation, async () => await this.#aiProvider?.getValidationConfiguration(tenantId, data))
+            .exhaustive();
+        const configs = [
+            globalConfig?.defaults,
+            globalConfig?.steps?.[step],
+            (isNotNull(categoryKey) && isDefined(globalConfig?.categories)) ? globalConfig.categories[categoryKey] : undefined,
+            (isNotNull(typeKey) && isDefined(globalConfig?.documentTypes)) ? globalConfig.documentTypes[typeKey] : undefined,
+            stepConfig,
+        ].filter(isDefined);
+        const model = mergeMostSpecific(configs, 'model');
+        const language = mergeMostSpecific(configs, 'language');
+        const systemAddition = resolveAdditions(configs.map((c) => c.prompt?.systemAddition));
+        const userAddition = resolveAdditions(configs.map((c) => c.prompt?.userAddition));
+        const systemOverride = mergeMostSpecific(configs.map((c) => c.prompt).filter(isDefined), 'systemOverride');
+        const userOverride = mergeMostSpecific(configs.map((c) => c.prompt).filter(isDefined), 'userOverride');
+        const extraction = this.mergeExtractionConfigs(configs.map((c) => c.extraction).filter(isDefined));
+        const classification = mergeMostSpecific(configs, 'classification');
+        return {
+            model,
+            language,
+            prompt: {
+                systemAddition,
+                userAddition,
+                systemOverride,
+                userOverride,
+            },
+            extraction,
+            classification,
+        };
+    }
+    mergeExtractionConfigs(configs) {
+        if (configs.length == 0) {
+            return undefined;
+        }
+        const properties = {};
+        for (const config of configs) {
+            if (isDefined(config?.properties)) {
+                for (const [key, value] of objectEntries(config.properties)) {
+                    properties[key] = value;
+                }
+            }
+        }
+        return {
+            title: mergeMostSpecific(configs, 'title'),
+            subtitle: mergeMostSpecific(configs, 'subtitle'),
+            date: mergeMostSpecific(configs, 'date'),
+            summary: mergeMostSpecific(configs, 'summary'),
+            tags: mergeMostSpecific(configs, 'tags'),
+            properties: (objectKeys(properties).length > 0) ? properties : undefined,
+        };
+    }
+    async resolveContextKeys(tenantId, data) {
+        if (isUndefined(data)) {
+            return { typeKey: null, categoryKey: null };
+        }
+        let type = ('type' in data) ? data.type : undefined;
+        let category = ('category' in data) ? data.category : undefined;
+        if (isUndefined(type) && hasOwnProperty(data, 'document') && isNotNull(data.document.typeId)) {
+            type = await this.#documentTypeRepository.load(data.document.typeId);
+        }
+        if (isUndefined(category) && isNotNullOrUndefined(type)) {
+            category = await this.#documentCategoryTypeService.loadCategory(tenantId, type.categoryId);
+        }
+        return {
+            typeKey: type?.key ?? null,
+            categoryKey: category?.key ?? null,
+        };
     }
 };
 DocumentManagementAiService = DocumentManagementAiService_1 = __decorate([
@@ -514,3 +478,42 @@ function tryAiOutputDateObjectToNumericDate(dateObject) {
     }
     return date;
 }
+export function mergeFieldInstructions(instructionsKey, field, aiConfig) {
+    return mergeInstructions(dataExtractionInstructionsRaw['Field Specific Instructions'][instructionsKey], [aiConfig.extraction?.[field]], { formatTemplate: getFormatTemplate(field) });
+}
+export function mergeInstructions(base, overrides, options = {}) {
+    let result = base;
+    for (const override of overrides) {
+        if (isUndefined(override)) {
+            continue;
+        }
+        if (isString(override)) {
+            result = override;
+            continue;
+        }
+        if (isDefined(override.format)) {
+            const template = options.formatTemplate ?? ((format) => `Use this format: ${format}`);
+            result = template(override.format);
+        }
+        if (isDefined(override.content)) {
+            const strategy = override.strategy ?? 'append';
+            if (strategy == 'replace') {
+                result = override.content;
+            }
+            else {
+                result = `${result}\n\n${override.content}`;
+            }
+        }
+    }
+    return result;
+}
+function mergeMostSpecific(configs, key) {
+    return configs.reduceRight((acc, c) => acc ?? c?.[key], undefined);
+}
+function resolveAdditions(additions) {
+    const filtered = additions.filter(isDefined);
+    return (filtered.length == 0) ? undefined : (filtered.length == 1) ? filtered[0] : filtered;
+}
+function getFormatTemplate(fieldName) {
+    return (format) => `Format the ${fieldName} of the document exactly as follows: ${format}`;
+}